poj3683 2-SAT 求解

题目：http://poj.org/problem?id=3683



题目大意：在一个结婚高潮的时段，很多人想结婚，但是只有一个神父可以主持婚礼，给出每组婚礼的两个开始时间a，b和婚礼的持续时间d，问能否主持所有的婚礼，若能，则输出每个婚礼占用的时间段，不能就输出NO



考查点：2-SAT判定加求解



思路：因为每个婚礼只有两个开始时间a或b，由于只有两种状态，所以可以看作是x和非x，然后利用n方的时间判断两个婚礼的开始时间之间是否有冲突，若有，非（I and j） = 1

然后化为析取式建立边。

建完边以后，就可以求强连通分图。判断是否有冲突，如有，输出NO。若无，则进行求解。

求解是先缩图，然后反向建边。拓扑排序后，从拓扑序中第一个缩点开始，遇到没有染过色的，染成红色，然后把这个缩点内的所有点的非所在的缩点染成蓝色。然后再找下一个没有被染过色的缩点，然后往复执行前面的过程。知道所有点都被染了色



提交情况 Accepted
1次



经验：如何思考一个问题是不是2-SAT问题。每个状态有两种可能（看作是1，0），状态之间又有一些约束条件。



收获：拥有了2-SAT问题求解的模板



AC code：

#include <stdio.h>

#include <string.h>



#define MAXN 3000

#define MAXE MAXN * MAXN

struct NODE{


int st, to;


int next;

};

NODE edges[MAXE], minedges[MAXE],
incde[MAXE];

int head[MAXN], minhead[MAXN],
minmap[MAXN];

int ad, edge2, edge1, top, times, mintotal;

int time[MAXN][2], d[MAXN], start[MAXN], strack[MAXN],
In_strack[MAXN], vis[MAXN], dfn[MAXN], low[MAXN];

int ru[MAXN], belong[MAXN], colour[MAXN],
tp[MAXN];



void In_edges(int x,
int y){


edges[ad].st = x;


edges[ad].to = y;


edges[ad].next = head[x];


head[x] = ad ++;

}



void Built_Map(int
n){


ad = 0;


memset(head, -1, sizeof(head));


for(int i = 0; i < n; i
++)


for(int j = i + 1; j < n; j
++){


if((time[i][0] <=
time[j][0] && time[i][0] + d[i]
> time[j][0]) || (time[j][0] <=
time[i][0] && time[j][0] + d[j]
> time[i][0])){


In_edges(i * 2, j * 2 + 1);


In_edges(j * 2, i * 2 + 1);


}


if((time[i][0] <=
time[j][1] && time[i][0] + d[i]
> time[j][1]) || (time[j][1] <=
time[i][0] && time[j][1] + d[j]
> time[i][0])){


In_edges(i * 2, j * 2);


In_edges(j * 2 + 1, i * 2 + 1);


}


if((time[i][1] <=
time[j][0] && time[i][1] + d[i]
> time[j][0]) || (time[j][0] <=
time[i][1] && time[j][0] + d[j]
> time[i][1])){


In_edges(i * 2 + 1, j * 2 + 1);


In_edges(j * 2, i * 2);


}


if((time[i][1] <=
time[j][1] && time[i][1] + d[i]
> time[j][1]) || (time[j][1] <=
time[i][1] && time[j][1] + d[j]
> time[i][1])){


In_edges(i * 2 + 1, j * 2);


In_edges(j * 2 + 1, i * 2);


}


}


edge1 = ad;

}



void dfs(int
u){


int p;


low[u] = dfn[u] = times ++;


vis[u] = 1;


In_strack[u] = 1;


strack[ ++ top] = u;


for(p = head[u]; ~p; p =
edges[p].next)


if(!vis[edges[p].to]){


dfs(edges[p].to);


low[u] = low[u] < low[edges[p].to] ? low[u] :
low[edges[p].to];


}


else


if(In_strack[edges[p].to])


low[u] = low[u] < low[edges[p].to] ? low[u] :
low[edges[p].to];


if(low[u] == dfn[u]){


incde[ad].to = u; incde[ad].st = mintotal;


incde[ad].next = minhead[mintotal]; minhead[mintotal] = ad
++;


In_strack[u] = 0;


belong[u] = mintotal;


while((p = strack[top--]) !=
u){


incde[ad].to = p; incde[ad].st = mintotal;


incde[ad].next = minhead[mintotal]; minhead[mintotal] = ad
++;;


In_strack[p] = 0;


belong[p] = mintotal;


}


mintotal ++;


}

}



void Tarjan(int
n){


int i;


times = ad = 0, top = -1, mintotal = 0;


memset(vis, 0, sizeof(vis));


memset(minhead, -1, sizeof(minhead));


dfn[0] = 0;


for(i = 0; i < n *
2; i ++)


if(!vis[i]) dfs(i);

}



void built_min_map(int
ed){


memset(minmap, -1, sizeof(minmap));


memset(ru, 0, sizeof(ru));


edge2 = 0;


for(int i = 0; i < ed; i
++)


if(belong[edges[i].st] !=
belong[edges[i].to]){


minedges[edge2].to = belong[edges[i].st];


minedges[edge2].next = minmap[belong[edges[i].to]];


minmap[belong[edges[i].to]] = edge2 ++;


ru[belong[edges[i].st]] ++;


}

}



void tuopu(int
mintotal){


int i,j, count = 0;


top = -1;


for(i = 0; i <
mintotal; i ++ )


if(!ru[i])


strack[++top] = i, tp[count ++] = i;


while(top >=
0){


j = strack[top--];


for(i = minmap[j]; ~i; i =
minedges[i].next){


ru[minedges[i].to] --;


if(ru[minedges[i].to] ==
0){


strack[++top] = minedges[i].to;


tp[count++] = minedges[i].to;


}


}


}

}



int Getans(int
n){


int i, p;


for(i = 0; i < n; i
++)


if(low[i * 2] == low[i * 2 + 1])
return 0;


built_min_map(edge1);


tuopu(mintotal);


memset(colour, -1, sizeof(colour));


for(i = 0; i <
mintotal; i ++)


if(colour[i] == -1){


colour[i] = 1;


for(p = minhead[i]; ~p; p =
incde[p].next)


colour[belong[incde[p].to ^ 1]] = 0;


}


for(i = 0; i < n; i
++)


if(colour[belong[i *
2]])


start[i] = time[i][0];


else


start[i] = time[i][1];

}



int main(){


int n, i, x, y, z, w;


while(~scanf("%d", &n)){


for(i = 0; i < n; i
++){


scanf("%d:%d %d:%d %d",
&x, &y, &z,
&w, &d[i]);


time[i][0] = x * 60 + y;


time[i][1] = z * 60 + w - d[i];


}


Built_Map(n);


Tarjan(n);


if(Getans(n)){


printf("YES\n");


for(i = 0; i < n; i
++)


printf("%.2d:%.2d %.2d:%.2d\n",
start[i] / 60, start[i] % 60, (start[i] + d[i]) / 60, (start[i] +
d[i]) % 60);


}


else printf("NO\n");


}


return 0;

}