9.28-10.04

/主要是图算法方面的， BFS. DFS. 生成树. 最短路径. 二分图. 最大流. 差分约束之类。

1.Catch That Cow

//直接BFS即可。 注意n>k的情况
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

int n, k;

int main()
{
    int ans = 1000000000;
    while (~scanf("%d%d", &n, &k))
    {
        ans = abs(n-k);
        if (n >= k)
        {
            printf("%d
", ans);
            continue;
        }
        queue<pair<int, int> > qu;
        while (!qu.empty()) qu.pop();
        set<int> st;
        qu.push(make_pair(n, 0));
        st.insert(n);
        while (!qu.empty())
        {
            int fir = qu.front().first;
            int sec = qu.front().second;
            if (ans <= sec) break;
            if (fir == k)
            {
                ans = sec;
                break;
            }
            else if (fir < k)
            {
                if (st.count(fir-1) == 0) qu.push(make_pair(fir-1, sec+1)), st.insertfir-1);
                if (st.count(fir*2) == 0) qu.push(make_pair(2*fir, sec+1)), st.insert(2*fir);
                if (st.count(fir+1) == 0) qu.push(make_pair(fir+1, sec+1)), st.insert(fir+1);
            }
            else ans = min(fir-k+sec, ans);
            qu.pop();
        }
        printf("%d
", ans);
    }
        
    return 0;
}

 2.Children of the Candy Corn

//Left && Right分着写的，懒得再合起来了。BFS即可。
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

const int maxn = 45;
char g[maxn][maxn];
int vis[maxn][maxn];
int t, m, n;
int sx, sy, ex, ey;

void init()
{
    for (int i = 0 ; i < maxn; ++i)
        for (int j = 0; j < maxn; ++j)
            g[i][j] = '#';
}

int workLeft()
{
    int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int p = 0, x = sx, y = sy, d = 1;
    if (sx == 1) p = 0;
    else if (sy == n) p = 1;
    else if (sx == m) p = 2;
    else p = 3;
    while (x != ex || y != ey)
    {
        d++;
        for (int i = 0; i < 4; ++i)
        {
            int xx = x + dir[(n+4-1)%4][0];
            int yy = y + dir[(n+4-1)%4][1];
            if (g[xx][yy] != '#') 
            {
                x = xx, y = yy, n = (n+4-1)%4;
                break;
            }
            else n = (n+1)%4;
        }
    }
    return d;
}

int workRight()
{
    int dir[4][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
    int x = sx, y = sy, d = 1;
 58     int p = 0;
    if (sx == 0) p = 0;
    else if (sy == 1) p = 1;
    else if (sx == m) p = 2;
    else p = 3;
    while (x != ex || y != ey)
    {
        d++;
        for (int i = 0; i < 4; ++i)
        {
            int xx = x + dir[(n+4-1)%4][0];
            int yy = y + dir[(n+4-1)%4][1];
            if (g[xx][yy] != '#')
            {
                x = xx, y = yy, n = (n+4-1)%4;
                break;
            }
            else n = (n+1)%4;
        }
    }    
    return d;
}

int workBest()
{
    int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    memset(vis, 0, sizeof(vis));
    queue<pair<pair<int, int>, int> > qu;
    qu.push(make_pair(make_pair(sx, sy), 1));
    vis[sx][sy] = 1;
     while (!qu.empty())
    {
        int x = qu.front().first.first;
        int y = qu.front().first.second;
        int d = qu.front().second;
        qu.pop();
        if (x == ex && y == ey) return d;
        for (int i = 0; i < 4; ++i)
        {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if (!vis[xx][yy] && g[xx][yy] != '#')
            {
                qu.push(make_pair(make_pair(xx, yy), d+1));
                vis[xx][yy] = 1;        
            }
        }
    }
}

int main()
{
    scanf("%d", &t);
    while (t--)
    {
        init();
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= m; ++i)
        {
            getchar();
            for (int j = 1; j <= n; ++j)
            {
                scanf("%c", &g[i][j]);
                if (g[i][j] == 'S')
                    sx = i, sy = j;
                if (g[i][j] == 'E')
                    ex = i, ey = j;
            }
        }
        printf("%d %d %d
", workLeft(), workRight(), workBest());
    }    

    return 0;
}

 3.Currency Exchange

//Bellman-Ford的变形
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

const int maxn = 105;

class Node
{
public:
    int a, b;
    double r, c;    
    Node(int aa, int bb, double rr, double cc): a(aa), b(bb), r(rr), c(cc){}
};

vector<Node> vec;
double dis[maxn];
double v;
int n, m, s;

void bellmanFord()
{
    memset(dis, 0, sizeof(dis));
    dis[s] = v;
    for (int i = 1; i <= n-1; ++i)
    {
        for (int j = 0; j < vec.size(); ++j)
            dis[vec[j].b] = max(dis[vec[j].b] ,(dis[vec[j].a]-vec[j].c)*vec[j].r);
    }
    
    for (int i = 0; i < vec.size(); ++i)
    {
        if (dis[vec[i].b] < (dis[vec[i].a]-vec[i].c)*vec[i].r)
        {
            printf("YES
");
            return ;
        }
    }
    puts("NO");
}

int main()
{
    while (~scanf("%d%d%d%lf", &n, &m, &s, &v))
    {
        vec.clear();
        int a, b;
        double r1, c1, r2, c2;
        for (int i = 0; i < m; ++i)
        {
            scanf("%d%d%lf%lf%lf%lf", &a, &b, &r1, &c1, &r2, &c2);
            Node node1(a, b, r1, c1), node2(b, a, r2, c2);
            vec.push_back(node1), vec.push_back(node2);
        }    
        bellmanFord();
    }    
    
    return 0;
}

 4.Wormholes

//依旧是BellmanFord即可，不过题目数据太差了，n的数据量不是500，所以开大dis数组即可。
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

#define INF 1e9
const int maxn = 10015;

class Lode
{
public:
    int s, e, t;
    Node(int ss, int ee, int tt): s(ss), e(ee), t(tt){}
};
vector<Node> vec;
int f, n, m, w;
int dis[maxn];

void init()
{
    vec.clear();
    for (int i = 0; i < maxn; ++i)
        dis[i] = INF;
}

void bellmanFord()
{
    dis[1] = 0;
    for (int i = 1; i < n-1; ++i)
    {
        for (int j = 0; j < vec.size(); ++j)
            dis[vec[j].e] = min(dis[vec[j].e], dis[vec[j].s]+vec[j].t);
    }
    for (int i = 0; i < vec.size(); ++i)
    {
        if (dis[vec[i].e] > dis[vec[i].s] + vec[i].t)
        {
            puts("YES");
            return ;
        }
    }
    puts("NO");
}

int main()
{
    scanf("%d", &f);
    while (f--)
    {
        init();
        scanf("%d%d%d", &n, &m, &w);
        int s, e, t;
        for(int i = 0; i < m; ++i)
        {
            scanf("%d%d%d", &s, &e, &t);
            Node node1(s, e, t);
            vec.push_back(node1);
            Node node2(e, s, t);
            vec.push_back(node2);             
        }
        for (int i = 0; i < w; ++i)
        {
            scanf("%d%d%d", &s, &e, &t);
            Node node(s, e, -t);
            vec.push_back(node);
        }
        bellmanFord();
    }
        
    return 0;
}

 5.昂贵的聘礼

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

#define INF 1e9
const int maxn = 105;

int price[maxn], g[maxn][maxn], level[maxn];
int dis[maxn], vis[maxn];
int n, m, ans;

void init()
{
    memset(price, 0, sizeof(price));
    memset(level, 0, sizeof(level));
    for (int i = 0; i <= n; ++i)
        for (int j = 0; j <= n; ++j)
            g[i][j] = INF;
}

int dijkstra()
{
    for (int i = 1; i <= n; ++i)
        dis[i] = price[i];
    for (int i = 1; i <= n; ++i)
    {
        int temp = INF, x;
        for (int j = 1; j <= n; ++j)
            if (!vis[j] && dis[j] < temp)
                temp = dis[x = j];
        vis[x] = 1;
        for (int j = 1; j <= n; ++j)
            if (dis[x]+g[x][j] < dis[j] && !vis[j])
                dis[j] = dis[x]+g[x][j];
    }
    return dis[1];
}

int main()
{
    while (~scanf("%d%d", &m, &n))
    {
        init();
        for (int i = 1; i <= n; ++i)
        {
            int x;
            scanf("%d%d%d", &price[i], &level[i], &x);
            for (int j = 0; j < x; ++j)
            {
                int t, v;
                scanf("%d%d", &t, &v);
                g[t][i] = v;
            }
            g[0][i] = price[i];
        }
        ans = INF;
        for (int i = 1; i <= n; ++i)
        {
            int minl = level[i];
            for<span> (int j = 1; j <= n; ++j)
            {
                if (level[j]-minl > m || minl > level[j]) vis[j] = 1;
                else vis[j] = 0;
            }
            int now = dijkstra();
            ans = min(now, ans);
        }
        printf("%d
", ans);
    }

    return 0;
}

 6.Intervals

//差分约束系统，差分约数系统的含义，其实就是如果有n个变量在m个形如aj-ai>=bk条件下，求解的此不等式的方法。而这种不等式的解法其实就是转化为图论的最小路的算法求解的。
根据题意可得不等式//Sbi - Sai >= ci//Si - Si-1 >= 0//Si-1 - Si >= -1
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
 9/span> #include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

#define INF 1000000007
#define MIN(a, b) (a > b ? b : a)
#define MAX(a, b) (a > b ? a : b)
#define MAXN 50005
const int maxn = 50005;
struct Edge
{
    int v;
    int w;
    int next;
}edge[MAXN*3];
int head[MAXN], d[MAXN], vis[MAXN];
int n, t, source, target;

void init()
{
    memset(edge, 0, sizeof(edge));
    memset(vis, 0, sizeof(vis));
    memset(head, -1, sizeof(head));
    t = 0;
    source = INF, target = -INF;
}

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

void spfa()
{
    for (int i = source; i <= target; ++i) d[i] = -INF;
    d[source] = 0;
    queue<int> qu;
    qu.push(source);
    while (!qu.empty())
    {
        int x = qu.front();
        qu.pop();
        vis[x] = 0;
        for (int e = head[x]; e != -1; e = edge[e].next)
            if (d[edge[e].v] < d[x]+edge[e].w)
            {
                d[edge[e].v] = d[x] + edge[e].w;
                if (!vis[edge[e].v])
                {
                    qu.push(edge[e].v);
65                     vis[edge[e].v] = 1;
                }
            }
    }
}

int main()
{
    int u, v, w;
    init();
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        addEdge(u, v+1, w);
        source = min(u, source);
        target = max(v+1, target);
    }
    for (int i = source; i < target; ++i)
    {
        addEdge(i, i+1, 0);
        addEdge(i+1, i, -1);    
    }
    spfa();
    printf("%d
", d[target]);
    
    return 0;
}

 7.World Exhibition

//差分约束，脑残了，一开始一直拿着带输出测试数据的代码提交，一直wa。。。隐含条件Aj-Ai=无穷大，Ai-Aj<=0
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <cstdlib>

using namespace std;

#define INF 1000000007
#define MIN(a, b) (a > b ? b : a)
#define MAX(a, b) (a > b ? a : b)
#define MAXN 1005
#define maxn 10005
struct Edge
{
    int v;
    int w;
    int next;
}edge[maxn*3];
int vis[MAXN], d[MAXN], head[MAXN], use[MAXN];
int t, T, n;

void init()
{
    t = 0;
    memset(edge, 0, sizeof(edge));
    for (int i = 0; i < MAXN; ++i)
        use[i] = 0, vis[i] = 0, d[i] = INF, head[i] = -1;
}

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

int spfa()
{
    queue<int> qu;
    while (!qu.empty()) qu.pop();
    d[1] = 0;
    qu.push(1);
    while (!qu.empty())
    {
        int x = qu.front();
        qu.pop();
        vis[x] = 0;
        for (int e = head[x]; e != -1; e = edge[e].next)
        {
            if (d[edge[e].v] > d[x]+edge[e].w)
            {
                d[edge[e].v] = d[x]+edge[e].w;
                if (!vis[edge[e].v])
                {
                    qu.push(edge[e].v);
                    vis[edge[e].v] = 1;
                    if (++use[edge[e].v] > n) return -1;
                }
            }
        }    
    }
    if (d[n] == INF) return -2;
    return d[n];
}

int main()
{
    scanf("%d", &T);
    while (T--)
    {
        init();
        int x, y;
        scanf("%d%d%d", &n, &x, &y);
        int a, b, c;
        for (int i = 0; i < x; ++i)
        {
            scanf("%d%d%d", &a, &b, &c);
            addEdge(a, b, c);
        }
        for (int i = 0; i < y; ++i)
        {
            scanf("%d%d%d", &a, &b, &c);
            addEdge(b, a, -c);
        }
        for (int i = 2; i <= n; ++i)
        {
            addEdge(i-1, i, INF);
            addEdge(i, i-1, 0);
        }
        printf("%d
", spfa());
    }    
    
    return 0;
}

 8.Schedule Problem

//差分约束，构建不等式然后选取最长路。我觉得这题不严谨。。比如FAF 1 2  2 1，我觉得应该是impossible...但是。。。
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <set>
#include <stdint.h>
#include <utility>
#include <map>
#include <cstdlib>
#include <queue>
#include <vector>
#include <numeric>
#include <list>
#include <bitset>
#include <exception>
#include <istream>
#include <ostream>
#include <stdexcept>
#include <functional>
#include <stack>
#include <unordered_set>

#define LL long long int
using namespace std;


#define MEM memset
#define MAX (a > b ? a : b)
#define MIN (a < b ? a : b)
#define MAXN 200000
#define LL long long int
#define INF 1000000007

struct Edge
{
    int v;
    int w;
    int next;
}edge[MAXN];
int d[MAXN], vis[MAXN], use[MAXN], weight[MAXN], head[MAXN], in[MAXN];
int ncas, n, t, a1, a2;
char ch[10];

void init()
{
    t = 0;
    memset(edge, 0, sizeof(edge));
    for (int i = 0; i < MAXN; ++i)
        vis[i] = weight[i] = use[i] = in[i] = 0, d[i] = -INF, head[i] = -1;
}

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

void judge()
{
    in[a1]++;
    if (strcmp(ch,"SAF") == 0) addEdge(a2, a1, weight[a2]);
    else if (strcmp(ch, "FAF") == 0) addEdge(a2, a1, weight[a2]-weight[a1]);
    else if (strcmp(ch, "FAS") == 0) addEdge(a2, a1, -weight[a1]);
    else addEdge(a2, a1, 0);
}

int spfa()
{
    int s = 0;
    queue<int> qu;
    while (!qu.empty()) qu.pop();
    d[s] = 0;
    qu.push(s);
    vis[s] = 1;
    while (!qu.empty())
    {
        int x = qu.front();
        qu.pop();
        vis[x] = 0;
        use[x]++;
        if (use[x] > n) return 1;
        for (int e = head[x]; e != -1; e = edge[e].next)
        {
            if (d[edge[e].v] < d[x]+edge[e].w)
            {
                d[edge[e].v] = d[x]+edge[e].w;
                if (!vis[edge[e].v])
                {
                    qu.push(edge[e].v);
                    vis[edge[e].v] = 1;
                }
            }
        }
    }
    for (int i = 1; i <= n; ++i)
        printf("%d %d
", i, d[i]);
    return 0;
}

int main()
{
    ncas = 1;
    while (~scanf("%d", &n) && n)
    {
        init();
        for (int i = 1; i <= n; ++i)
            scanf("%d", &weight[i]);
        while (scanf("%s", ch) && ch[0] != '#')
        {
            scanf("%d %d", &a1, &a2);
            judge();
        }
        for (int i = 1; i <= n; ++i)
            addEdge(0, i, 0);
        printf("Case %d:
", ncas++);
        if (spfa()) puts("impossible");
        puts("");
    }

    return 0;
}

 9.Truck History

//Prim算法
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <set>
#include <utility>
#include <map>
#include <cstdlib>
#include <queue>
#include <vector>
#include <numeric>
#include <list>
#include <bitset>
#include <exception>
#include <istream>
#include <ostream>
#include <qtdexcept>
#include <functional>
#include <stack>

#define LL long long int
using namespace std;


#define MEM memset
#define MAX (a > b ? a : b)
#define MIN (a < b ? a : b)
#define MAXN 2010
#define LL long long int
#define INF 1000000007

int g[MAXN][MAXN];
int d[MAXN], vis[MAXN];
char ch[MAXN][10];
int n;

void init()
{
    memset(vis, 0, sizeof(vis));
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
        {
            if (i == j) g[i][j] = 0;
            else
            {
                int cnt = 0;
                for (int k = 0; k < 7; ++k)
                    if (ch[i][k] != ch[j][k]) cnt++;
                g[i][j] = g[j][i] = cnt;
            }
        }
    for (int i = 0; i < n; ++i)
        d[i] = g[0][i];
}

int prim()
{
    init();
    int k = 0, idx, len, ans = 0;
    vis[k] = 1;
    for (int i = 1; i < n; ++i)
    {
        len = INF;
        for (int j = 0; j < n; ++j)
            if (!vis[j] && d[j] < len)
                len = d[idx = j];
        ans += len;
        vis[idx] = 1;
        for (int j = 0; j < n; ++j)
            if (!vis[j] && g[idx][j] < d[j])
                d[j] = g[idx][j];
    }
    return ans;
}

int main()
{
    while (~scanf("%d", &n) && n)
    {
        for (int i = 0; i < n; ++i)
            scanf("%s", ch[i]);
        printf("The highest possible quality is 1/%d.
", prim());
    }

    return 0;
}

 10.Highways

//Prim算法
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>

using namespace std;

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

int t, n;
int d[MAXN], vis[MAXN];
int g[MAXN][MAXN];

void init()
{
    for (int i = 0; i < n; ++i)
        d[i] = g[0][i], vis[i] = 0;
}

int prim()
{
    init();
    int ans = -INF;
    vis[0] = 1;
    for (int i = 1; i < n; ++i)
    {
        int min_cost = INF, idx = 0;
        for (int j = 0; j < n; ++j)
            if (!vis[j] && d[j] < min_cost)
                min_cost = d[idx = j];
        ans = max(ans, min_cost);
        vis[idx] = 1;
        for (int j = 0; j < n; ++j)
            if (!vis[j] && d[j] > g[idx][j])
                d[j] = g[idx][j];
    }
    return ans;
}

int main()
{

    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                scanf("%d", &g[i][j]);
        printf("%d
", prim());
    }

    return 0;
}

 11.Agri-Net

//prim算法
#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)

int n;
int d[MAXN], vis[MAXN];
int g[MAXN][MAXN];

void init()
{
    for (int i = 0; i < n; ++i)
        d[i] = g[0][i], vis[i] = 0;
}

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

int main()
{
    while (~scanf("%d", $amp;n))
    {
        for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            scanf("%d", &g[i][j]);
        printf("%d
", prim());
    }

    return 0;
}

 12.Agri-Net

//Kruskal算法 与上面prim对比一下
#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 u;
    int v;
    int w;
}edge[MAXN*MAXN];
int n;
int father[MAXN];

int cmp(const void* a, const void* b)
{
    return ((Edge*)a)->w - ((Edge*)b)->w;
}

int findFather(int val)
{
    if (father[val] == val) return val;
    return father[val] = findFather(father[val]);
}

void unionFather(int x, int y)
{
    int xx = findFather(x);
    int yy = findFather(y);
    father[xx] = father[yy];
}

int main()
{
    while (~scanf("%d", &n))
    {
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
            {
                scanf("%d", &edge[i*n+j].w);
                edge[i*n+j].u = i, edge[i*n+j].v = j;
            }
        for (int i = 0; i < n; ++i) father[i] = i;
        qsort(edge, n*n, sizeof(Edge), cmp);
        int ans = 0;
        for (int i = 0; i < n*n; ++i)
        {
            if (edge[i].u >= edge[i].v) continue;
            if (findFather(edge[i].u) != findFather(edge[i].v))
            {
                ans += edge[i].w;
                unionFather(edge[i].u, edge[i].v);
            }
        }
        printf("%d
", ans);
    }

    return 0;
}