Google Code Jam 2015 R2 C

题意：给出若干个句子，每个句子包含多个单词。确定第一句是英文，第二句是法文。后面的句子两者都有可能。两个语种会有重复单词。

现在要找出一种分配方法（给每个句子指定其文种），使得既是英文也是法文的单词数量最少。

分析：网络流的最小割。

建图方法如下，每个句子一个点。每个单词一个点。句子向其所属的单词连双向无穷流量边。把第一个句子作为起点，第二句作为终点。

现在我们要割掉一些单词，使得起点无法到达终点。

图的意义是这样的。如果我们能找到一条从起点到达终点的通路，那么中间一定有一个过程是从一个英文句子跳到一个单词，然后跳到一个法文句子。这就说明该单词既是英文又是法文。

而如果找不到通路，把所有能到达的句子点归为英文，其余的归为法文。这样就成功地完成了划分任务，而没有同属于两个语言的单词。

所以，割掉单词使得图没有通路就是一种划分的充要条件。

割点的方法就是拆点，每个单词拆成两点，一个负责入边，一个负责出边。中间加一条流量为1的边。

本题还有一个难点就是输入，每个句子要自己根据空格划分成单词。

stringstream可以将字符串作为输入流，从中读入内容。用stringstream sin(inputstring); 之后读入方法与cin一样。需要包含sstream头文件。

char*转化成string可以直接用等号赋值。

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <map>

#include <vector>

#include <string>

#include <sstream>

using namespace std;



#define D(x) 



const int MAX_N = 300;

const int MAX_DIC = 1010;

const int MAX_WORD_NUM = 20;



const int MAX_NODE_NUM = (MAX_N * 10 + 2000) * 2 + MAX_N;

const int MAX_EDGE_NUM = (int)(1e6);

#define INF 0x3f3f3f3f



struct Edge

{

    int next, v, f;

    Edge()

    {}

    Edge(int next, int v, int f):next(next), v(v), f(f)

    {}

} edge[MAX_EDGE_NUM * 2];



int head[MAX_NODE_NUM];

int q[MAX_NODE_NUM];

bool vis[MAX_NODE_NUM];

int cur[MAX_NODE_NUM];

int dep[MAX_NODE_NUM];

int edge_cnt;

int path[MAX_NODE_NUM];

int front, rear, q_size;



void add_edge(int u, int v, int f)

{

    edge[edge_cnt] = Edge(head[u], v, f);

    head[u] = edge_cnt++;

    edge[edge_cnt] = Edge(head[v], u, 0);

    head[v] = edge_cnt++;

}



void init()

{

    edge_cnt = 0;

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

}



void q_init(int size)

{

    front = 0;

    rear = 0;

    q_size = size;

}



void q_push(int a)

{

    q[rear++] = a;

    rear %= q_size;

}



int q_pop()

{

    int ret = q[front++];

    front %= q_size;

    return ret;

}



void bfs(int s, int t)

{

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

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

    q_init(MAX_NODE_NUM);

    q_push(s);

    vis[s] = true;

    dep[s] = 0;

    while (front != rear && !vis[t])

    {

        int u = q_pop();

        for (int i = head[u]; ~i; i = edge[i].next)

        {

            int v = edge[i].v;

            if (!vis[v] && edge[i].f > 0)

            {

                q_push(v);

                vis[v] = true;

                dep[v] = dep[u] + 1;

            }

        }

    }

}



int add_flow(int path[], int &path_n)

{

    int min_edge = -1, delta = INF;

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

    {

        if (edge[path[i]].f < delta)

        {

            delta = edge[path[i]].f;

            min_edge = i;

        }

    }

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

    {

        edge[path[i]].f -= delta;

        edge[path[i] ^ 1].f += delta;

    }

    path_n = min_edge;

    return delta;

}



int last_node(int path[], int path_n, int s)

{

    if (path_n)

        return edge[path[path_n - 1]].v;

    return s;

}



int find_next(int start)

{

    for (int e = cur[start]; ~e; e = edge[e].next)

        if (edge[e].f && dep[start] + 1 == dep[edge[e].v])

            return e;

    return -1;

}



int dfs(int s, int t)

{

    int ret = 0;

    int path_n = 0;

    int x = s;

    memcpy(cur, head, sizeof(cur));

    while (true)

    {

        if (x == t)

        {

            ret += add_flow(path, path_n);

            x = last_node(path, path_n, s);

        }

        int next_edge = find_next(x);

        cur[x] = next_edge;

        if (next_edge == -1)

        {

            if (path_n == 0)

                break;

            dep[x] = -1;

            --path_n;

            x = last_node(path, path_n, s);

            continue;

        }

        path[path_n++] = next_edge;

        x = edge[next_edge].v;

    }

    return ret;

}



int dinic(int s, int t)

{

    int ret = 0;

    while (true)

    {

        bfs(s, t);

        if (dep[t] == -1)

            return ret;

        ret += dfs(s, t);

    }

    return -1;

}





int n;

map<string, int> dictionary;

vector<string> word[MAX_N];



void input()

{

    dictionary.clear();

    scanf("%d", &n);

    getchar();

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

    {

        word[i].clear();

        char st[MAX_DIC * MAX_WORD_NUM];

        fgets(st, MAX_DIC * MAX_WORD_NUM, stdin);

        string s = st;

        stringstream sin(s);

        while (sin >> s)

        {

            if (dictionary.find(s) == dictionary.end())

                dictionary[s] = dictionary.size() - 1;

            word[i].push_back(s);

        }

    }

}



int work()

{

    init();

    for (int i = 0; i < (int)dictionary.size(); i++)

    {

        int id1 = i * 2 + n;

        int id2 = id1 + 1;

        add_edge(id1, id2, 1);

    }

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

    {

        for (int j = 0; j < (int)word[i].size(); j++)

        {

            int id = dictionary[word[i][j]];

            int id1 = id * 2 + n;

            int id2 = id1 + 1;

            add_edge(i, id1, INF);

            add_edge(id2, i, INF);

        }

    }

    return dinic(0, 1);

}



int main()

{

    int t;

    scanf("%d", &t);

    int case_num = 0;

    while (t--)

    {

        case_num++;

        printf("Case #%d: ", case_num);

        input();

        printf("%d\n", work());

        bfs(0, 1);

    }

    return 0;

}

View Code