Butterfly

问题描述：有一群旅行爱好者，有一天，他们带回了n只蝴蝶回来。他们相信每一只都属于两个不同种类中的一种，为了讨论方便，我们称它们为A与B。他们想把n只标本分成两组——一些属于A且一些属于B——但是直接标记任何一个标本对于他们是非常困难，因此他们决定采用下面的方法。

对每对标本i和j，他们细心地把它们放到一起研究。如果他们以自己的判断足以确信，那么他们把这对蝴蝶标记为“相同”（这意味着他们相信这两只来自同一类）或者是“不同”（这意味着他们相信这两只来自不同的类）。他们也可以对某些标本判断不出来而弃权，在这种情况下，我们称这对标本是不明确的。

现在他们有n只标本的集合，还有对那些没有弃权的标本对的m个判断的集合（“相同”或者“不同”）。他们想知道这个数据与每只蝴蝶来自A和B中的一个类的想法是否一致。更具体地说，如果对每对蝴蝶按照下述方式标记A或B是可能的，即对每个标为“相同”的（i，j）对，就是i与j有相同标记的情况；对每个标为“不同”的（i，j）对，就是i与j有不同标记的情况。那么我们可以说这m个判断是一致的。他们正在冥思苦想自己的判断是否是一致的。请你帮他们设计合理的算法解决该问题。

输入：输入包含多组数据，以文件结束符为终止。

每组数据第一行为两个整数，分别是n和m：
n为蝴蝶的数量，编号从0到n-1
m为关系的数量

接下来是m组关系数据，每组数据占一行，为三个整数，前两个整数表示蝴蝶的编号，第三个整数为关系的种类（相同或者不同）：
0为相同，1为不同

1 < n <= 1000
1 < m <= 100000

输出：合理就输出YES
不合理就输出NO

样例输入：

3 3

0 1 0

1 2 1

0 2 1

3 3

0 1 0

1 2 1

0 2 0

样例输出

YES

NO

---

求解

输入的是m组关于n个数据点之间的两两的关系，关系要么为一致，要么为不一致，判断最终生成的关系是否出现矛盾，即通过某组关系判断两个节点是属于同一类，然而通过另外一组关系判断其不属于同一类的情况，归根结底就是染色问题。对输入的的关系，我们对其进行染色，假设一个顶点为颜色1，当两个顶点一致时，判断另外一个顶点是否染色，若未染色另外一个顶点也染为颜色1，若已经染色，则判断染的颜色是否一致，不一致时，break，输出结果NO；当输入的两个顶点不一致时，判断另外一个顶点是否染色，若染色，判断染的颜色是否不一致，若一致，则break，输出NO，若未染颜色，则判断对另外一个顶点染颜色2，以此类推；采用BFS，上述过程中，记录所有与“根”（相对的）节点相连的顶点，压入一个队列，之后对队列的所有的元素重复上述过程即可。

整个代码如下：

#include<stdlib.h>
#include<iostream>
#include<queue>
#include<string>
#include<string.h>

using namespace std;

int n, m;
int relation[1005][1005];//表示输入蝴蝶的关系
int vis[1005];//用于标记是否已经寻找过该关系
int state[1005];//用于存储是每只蝴蝶的颜色
queue<int> prepare_vist;//创建用于入队列的准备广度优先搜索的对象
int index_1, index_2;
int relation_data;
bool suc;//用于标记是否成功

bool bfs(int node)
{
    //遍历所有与节点i相连的点
    if (vis[node])
        return true;//访问过则直接返回
    vis[node] = 1;
    if (state[node] == 0)
        state[node] = 1;//初始时node未染色，则赋值颜色1
    for (int j = 0; j < n; j++)
    {
        if (relation[node][j] == 1)//颜色相异时
        {
            if (!state[j])//未染色
            {
                state[j] = 3 - state[node];
                prepare_vist.push(j);//节点j与node有关系，入队
            }
            else if (state[node] == state[j])//出现染色不一致的情况
            {
                //suc = false;
                return false;
            }
        }
        if (relation[node][j] == 2)//颜色相同时
        {
            if (state[j] == 0)
            {
                state[j] = state[node];
                prepare_vist.push(j);
            }
            else if (state[node] != state[j])
            {
                //suc = false;
                return false;
            }
        }
        //relation[node][j]==0，没有明确的关系，则不能够确定
    }
    return true;

}

int main()
{
    while (scanf("%d%d", &n,&m) != EOF)
    {
        suc = true;
        memset(relation, 0, sizeof(relation));
        memset(state, 0, sizeof(state));
        memset(vis, 0, sizeof(vis));
        //c++标准库并不带有使得队列元素清空的操作
        while (!prepare_vist.empty())
        {
            prepare_vist.pop();
        }
        for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &index_1, &index_2,&relation_data);
            relation[index_1][index_2] = 2 - relation_data;//1为不同，2为相同
            relation[index_2][index_1] = 2 - relation_data;
        }
        //编写算法
        for (int i = 0; i < n; i++)
        {
            prepare_vist.push(i);//准备遍历的元素入队
            while (!prepare_vist.empty())
            {
                if (!bfs(prepare_vist.front()))
                {
                    suc = false;
                    break;
                }
                prepare_vist.pop();
            }


        }
        if (!suc)
            cout << "NO" << endl;
        if (suc)
            cout << "YES" << endl;
    }
    return 0;
}

注意到，输入的数据可能包含多个连通子图，所以在初始时，需要指定一个颜色，根据此顶点与其它顶点的关系（把其它顶点依次压入队列），来进行染色；对于一个心得并未赋值的顶点，应是一个连通子图中的一个起始顶点，因为如果属于另外一个已经遍历的连通子图，其应该被染色，因为总能够找到一个路径使得其能够与起始点连接；所以需要进行判断并且赋值：

if (state[node] == 0)
        state[node] = 1;//初始时node未染色，则赋值颜色1

注意到，因为循环中包含了所有顶点的遍历，所以对于两个顶点，会遍历两次，但是输入时仅输入一个顶点的关系，所以需要在输入时做一个trick：

for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &index_1, &index_2,&relation_data);
            relation[index_1][index_2] = 2 - relation_data;//1为不同，2为相同
            relation[index_2][index_1] = 2 - relation_data;//trick
        }

另外POJ对于memset必须需要包括头文件:

#include<string>
#include<string.h>

同时，C++标准库并没有直接清空队列的操作，需要写一个loop进行清空

while (!prepare_vist.empty())
        {
            prepare_vist.pop();
        }