10.05-10.11

//本周依旧做一下图算法的题目，尽量少用algorithm里的函数，自己写熟悉熟悉。

1.The Unique MST

解析：该题为次小生成树问题。

次小生成树的求解过程:

1、找到最小生成树，值为mst

2、最小生成树种的点：找到每一个点到其它点的路径上的最大边权值 dp[i][j]表示i到j路径上的最大边权值

3、加一条不在最小生成树上的边。比如i - k，同时删除在最小生成树上i -> k路径上最大的一个边权值dp[i][k]; 这样会得到 new_mst，在这些new_mst中找一个最小的，就是次小生成树的值

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>

using namespace std;

#define INF 1000000007
#define MAXN 105
#define MAX(a, b) (a > b ? a : b)
#define MIN(a, b) (a < b ? a : b)

struct Edge
{
    int v;
    int next;
}edge[100010];

int t, n, m, T;
int d[MAXN], vis[MAXN], pre[MAXN], head[MAXN];
int g[MAXN][MAXN], dp[MAXN][MAXN], in_mst[MAXN][MAXN];

void init()
{
    t = 0;
    for (int i = 0; i <= n; ++i)
        for (int j = 0; j <= n; ++j)
            g[i][j] = (i == j ? 0 : INF);
    memset(head, -1, sizeof(head));
    memset(in_mst, 0, sizeof(in_mst));
    memset(dp, 0, sizeof(dp));
}

void addEdge(int u, int v)
{
    edge[t].v = v;
    edge[t].next = head[u];
    head[u] = t++;
}

int prim()
{
    int ans = 0;

    for (int i = 1; i <= n; ++i)
        d[i] = INF, pre[i] = 0, vis[i] = 0;
    pre[1] = 0, d[1] = 0;
    for (int i = 1; i <= n; ++i)
    {
        int min_cost = INF, idx = 0;
        for (int j = 1; j <= n; ++j)
            if (!vis[j] && min_cost > d[j])
                min_cost = d[idx = j];
        vis[idx] = 1;
        ans += min_cost;
        for (int j = 1; j <= n; ++j)
            if (!vis[j] && d[j] > g[idx][j])
                d[j] = g[idx][j], pre[j] = idx;
    }
    for (int i = 1; i <= n; ++i)
        if (pre[i]) in_mst[pre[i]][i] = in_mst[i][pre[i]] = 1;
    for (int i = 1; i <= n; ++i)
        if (pre[i])
            addEdge(pre[i], i), addEdge(i, pre[i]);

    return ans;
}

void dfs(int u, int v, int w)
{
    vis[v] = 1;
    dp[u][v] = w;
    for (int e = head[v]; e != -1; e = edge[e].next)
        if (!vis[edge[e].v])
            dfs(u, edge[e].v, max(w, g[v][edge[e].v]));
}

int main()
{
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &n, &m);
        init();
        int u, v, w;
        while (m--)
        {
            scanf("%d%d%d", &u, &v, &w);
            g[u][v] = g[v][u] = w;
        }
        int mst = prim();
        int ans = INF;
        for (int i = 1; i <= n; ++i)
        {
            memset(vis, 0, sizeof(vis));
            dfs(i, i, 0);
        }
        for (int i = 1; i <= n; ++i)
            for (int j = i+1; j <= n; ++j)
                if (!in_mst[i][j] && g[i][j] != INF)
                    ans = min(ans, mst-dp[i][j]+g[i][j]);
        if (ans == mst) puts("Not Unique!");
        else printf("%d
", mst);
    }

    return 0;
}

 2.Sorting It All Out

//添加一条边就要判断一下，最后判断出Sorted sequence cannot be determined.
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>

using namespace std;

#define INF 1000000007
#define MAXN 30
#define MAX(a, b) (a > b ? a : b)
#define MIN(a, b) (a < b ? a : b)

int n, m, pos1, pos2, pos3;
char ch[5];
int in[MAXN], ans[MAXN];
int g[MAXN][MAXN];

int work()
{
    int temp[MAXN], total = 0, idx = -1, flag = 0;
    for (int i = 0; i < n; ++i)
        temp[i] = in[i];
    for (int i = 0; i < n; ++i)
    {
        int cnt = 0;
        for (int j = 0; j < n; ++j)
            if (temp[j] == 0) idx = j, cnt++;
        if (cnt == 0) return 0;
        if (cnt > 1) flag = 1;
        temp[idx]--; ans[total++] = idx;
        for (int j = 0; j < n; ++j)
            if (g[idx][j]) temp[j]--;
    }
    if (flag) return -1;
    return 1;
}

int main()
{
    while (~scanf("%d%d", &n, &m) && n+m!=0)
    {
        int flag = 0;
        memset(g, 0, sizeof(g));
        memset(in, 0, sizeof(in));
        for (int i = 0; i < m; ++i)
        {
            scanf("%s", ch);
            if (flag) continue;
            g[ch[0]-'A'][ch[2]-'A'] = 1;
            in[ch[2]-'A']++;
            int ret = work();
            if (ret == 0)
            {
                printf("Inconsistency found after %d relations.
", i + 1);
                flag = 1;
            }
            else if (ret == 1)
            {
                printf("Sorted sequence determined after %d relations: ", i + 1);
                for (int j = 0; j < n; ++j) printf("%c", ans[j]+'A');
                puts(".");
                flag = 1;
            }
        }
        if (!flag) puts("Sorted sequence cannot be determined.");
    }

    return 0;
}

 3.The Cow Lexicon

//先求出g[i][j]两点之间最少删除字符，然后DP，感觉测试数据应该比较弱，因为我1A了。。。
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>

using namespace std;

#define INF 1000000007
#define MAXN 310
#define MAX(a, b) (a > b ? a : b)
#define MIN(a, b) (a < b ? a : b)

char msg[MAXN];
int W, L;
int dis[MAXN];
char ch[610][MAXN];
int g[MAXN][MAXN];

int main()
{
    for (int i = 0; i < MAXN; ++i)
        for (int j = i; j < MAXN; ++j)
            g[i][j] = j-i+1;
    scanf("%d%d", &W, &L);
    scanf("%s", msg);
    for (int i = 0; i < W; ++i) scanf("%s", ch[i]);
    for (int i = 0; i < W; ++i)
    {
        for (int j = 0; j < L; ++j)
        {
            if (ch[i][0] == msg[j])
            {
                int x = j, y = 0, cnt = 0;
                while (x < L && y < strlen(ch[i]))
                {
                    if (msg[x] == ch[i][y]) x++, y++;
                    else cnt++, x++;
                }
                if (y == strlen(ch[i]))
                    g[j][x-1] = min(cnt, g[j][x-1]);
            }
        }
    }
    for (int i = 0; i < MAXN; ++i) dis[i] = i+1;
    for (int i = 0; i < L; ++i)
    {
        int pre = i == 0 ? 0 : dis[i-1];
        for (int j = i; j < L; ++j)
            dis[j] = min(pre+g[i][j], dis[j]);
    }
    printf("%d
", dis[L-1]);

    return 0;
}

 4.Word Pattern

//水题
class Solution {
public:
    bool wordPattern(string pattern, string str) {
        vector<string> v;
        v.clear();
        string add = "";
        for (int i = 0; i < str.length(); ++i)
        {
            if (str[i] == ' ')
                v.push_back(add), add = "";
            else add += str[i];
        }
        if (add != "")v.push_back(add);
        if (pattern.length() != v.size()) return false;
        for (int i = 0; i < pattern.length(); ++i)
        {
            for (int j = i+1; j < pattern.length(); ++j)
            {
                if (pattern[i] == pattern[j] && v[i] != v[j]) return false;
                if (pattern[i] != pattern[j] && v[i] == v[j]) return false;        
            }
        }
        return true;
    }
};

 //关于图匹配的一些算法还是有点麻烦==。边学边做。。。

5.Strategic Game

//最小顶点覆盖
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <fstream>
#include <cstdlib>
#define NDEBUG
#include <cassert>

using namespace std;

#define INF 1000000007
#define MIN(a, b) (a > b ? b : a)
#define MAX(a, b) (a > b ? a : b)
#define MAXN 2005

struct Edge
{
    int v;
    int next;    
};

int cnt, n;
int vis[MAXN], link[MAXN], head[MAXN];
Edge edge[MAXN*MAXN];

void init()
{
    cnt = 0;
    memset(head, -1, sizeof(head));
}

void addEdge(int u, int v)
{
    edge[cnt].v = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;    
}

int dfs(int u)
{
    for (int e = head[u]; ~e; e = edge[e].next)
    {
        int v = edge[e].v;
        if (!vis[v])
        {
            vis[v] = 1;
            if (link[v] == -1 || dfs(link[v]))
            {
                link[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

int match()
{
    int ans = 0;
    memset(link, -1, sizeof(link));
    for (int i = 0; i < n; ++i)
    {
        memset(vis, 0, sizeof(vis));
        if (dfs(i)) ans++;
    }
    return ans;
}

int main()
{
    while (~scanf("%d", &n))
    {
        init();
        for (int i = 0; i < n; ++i)
        {
            int u, v, k;
            scanf("%d:(%d)", &u, &k);
            while (k--)
            {
                scanf("%d", &v);
                addEdge(u, v);
                addEdge(v, u);
            }
        }
        printf("%d
", match()/2);
    }    
    
    return 0;
}

 6.Machine Schedule

//匈牙利算法，0的时候无需重启，所以处理的时候是从1开始的，而不是从0
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <fstream>
#include <cstdlib>
#define NDEBUG
#include <cassert>

using namespace std;

#define INF 1000000007
#define MIN(a, b) (a > b ? b : a)
#define MAX(a, b) (a > b ? a : b)
#define MAXN 105

int n, m, k;
int link[MAXN], vis[MAXN];
int edge[MAXN][MAXN];

void init()
{
    memset(edge, 0, sizeof(edge));    
    memset(link, -1, sizeof(link));
}

int dfs(int u)
{
    for (int j = 1; j < m; ++j)
    {
        if (edge[u][j] && !vis[j])
        {
            vis[j] = 1;
            if (link[j] == -1 || dfs(link[j]))
            {
                link[j] = u;
                return 1;
            }
        }
    }
    return 0;    
}

int match()
{
    int ans = 0;
    for (int i = 1; i < n; ++i)
    {
        memset(vis, 0, sizeof(vis));
        ans += dfs(i);
    }
    return ans;
}

int main()
{
    while (~scanf("%d", &n) && n)
    {
        init();
        scanf("%d%d", &m, &k);
        int j, x, y;
        for (int i = 0; i < k; ++i)
        {
            scanf("%d%d%d", &j, &x, &y);
            edge[x][y] = 1;
        }
        printf("%d
", match());
    }    
    return 0;
}