2017-2018 ACM-ICPC, Asia Daejeon Regional Contest Solution

A：Broadcast Stations

留坑。

B：Connect3

题意：四个栈，每次放棋子只能放某个栈的栈顶，栈满不能放，现在给出(1, x) 表示黑子放在第x个栈的第一个位置，白子放在第b个栈的第a个位置并且是胜利局势的情况有几种，只要有三个相同的连在一起就是赢了

思路：数据很小，暴力搜索即可，注意判重。

#include <bits/stdc++.h>

using namespace std;

int x, a, b;

int G[10][10];

// 0 not done
// 1 white
// 2 black

inline string Hash()
{
    string ans = "";
    for (int i = 1; i <= 4; ++i)
        for (int j = 1; j <= 4; ++j)
        {
            ans += G[i][j] + '0'; 
        }
    return ans;
}

map <string, bool> mp;

int cnt[10];  

inline bool ok(int x, int y)
{
    if (x < 0 || x > 4 || y < 0 || y > 4) return false;
    return true;
}

int Move[][2] = 
{
     0,  1,
     0, -1,
     1,  0,
    -1,  0,
    -1, -1,
    -1,  1,
     1, -1,
     1,  1,
};

inline bool check(int x, int y)
{
    int color = G[x][y];
    for (int i = 0; i < 8; ++i)
    {
        int nx = x + Move[i][0];
        int ny = y + Move[i][1];
        int nnx = nx + Move[i][0];
        int nny = ny + Move[i][1];
        if (ok(nx, ny) && ok(nnx, nny))
            if (G[nx][ny] == color && G[nnx][nny] == color) 
                return true;
        nx = x + Move[i][0];
        ny = y + Move[i][1];
        nnx = x - Move[i][0];
        nny = y - Move[i][1];
        if (ok(nx, ny) && ok(nnx, nny))
            if (G[nx][ny] == color && G[nnx][nny] == color)
                return true;
    }        
    return false;
}

int tot;

inline void DFS(int x, int y, int vis)
{
    if (check(x, y))
    {
        if (vis == 1) return;
        if (x == b && y == a) 
        {
            string s = Hash();
            if(mp[s] == false)
            {
                mp[s] = true;
                tot++;
            }
        }
        return;
    }
//    if (x == b && y == a)
//    {
//        if (check())
//        {
//            string s = Hash();
//            if (mp[s] == false)
//            {
//                mp[s] = true;
//                tot++;
//            }
//        }
//        return;
//    }
    for (int i = 1; i <= 4; ++i)
    {
        if (cnt[i] < 4)
        {
            cnt[i]++;
            G[i][cnt[i]] = vis;
            DFS(i, cnt[i], vis == 1 ? 2 : 1);
            G[i][cnt[i]] = 0;
            cnt[i]--; 
        }
    }
}

inline void Init()
{
    memset(cnt, 0, sizeof cnt);
       memset(G, 0, sizeof G);    
    mp.clear();
    tot = 0;
}


int main()
{
    while (scanf("%d%d%d", &x, &a, &b) != EOF)
    {
        Init();
        cnt[x]++; G[x][1] = 2;
        DFS(x, 1, 1);
        cout << tot << endl;
    }
}

C：Game Map

题意：给出n个点，以及m条无向边，然后两个点之间如果有边那么度数大的那个点可以走到度数小的那个点，求最后从任意一个点出发，最远能走的路径的长度。

思路：显然，重新建图之后两个点之间最多有一个边，那么显然是若干棵树的结构，树形DP即可

#include<bits/stdc++.h>

using namespace std;

#define N 100010
#define M 1000010

struct node{
    int v,nx;
    inline node(){}
    inline node(int v,int nx) :v(v), nx(nx){}
}G[M];

int n, m;
int head[N], vis[N], dp[N], du[N], ans;
int tot;

inline void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
    memset(vis, 0, sizeof vis);
    memset(dp, 0, sizeof dp);
    memset(du, 0, sizeof du);
}

inline void addedge(int u,int v)
{
    G[tot] = node(v, head[u]);
    head[u] = tot++;
    G[tot] = node(u, head[v]);
    head[v] = tot++;
}

inline void DFS(int u)
{
    dp[u] = 1;
    vis[u] = 1;
    int tmp = 0;
    for(int i = head[u]; ~i; i = G[i].nx)
    {
        int v = G[i].v;
        if(du[v] > du[u])
        {
            if(!vis[v]) DFS(v);
            tmp = max(tmp, dp[v]);
        }    
    }
    dp[u] += tmp;
    ans = max(ans, dp[u]);
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        init();
        for(int i = 1; i <= m; ++i)
        {
            int u,v;
            scanf("%d %d",&u,&v);
            addedge(u, v);
            du[u]++;
            du[v]++;
        }
        for(int i = 0; i < n; ++i)
        {
            if(!vis[i]) DFS(i);
        }
        printf("%d
", ans);
    }
    return 0;
}

D：Happy Number

水。

#include <bits/stdc++.h>

using namespace std;

map <int, bool> mp;

int n;

inline int Get(int x)
{
    int tot = 0;
    while (x)
    {
        int num = x % 10;
        tot += num * num;
        x /= 10;
    }
    return tot;
}

inline bool solve()
{
    mp.clear();
    while (true)
    {
        int num = Get(n);
        if (num == 1) return true;
        n = num;
        if (mp[num] == true)
            return false;
        mp[num] = true;
    }
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        puts(solve() ? "HAPPY" : "UNHAPPY");
    }
}

E：How Many to Be Happy?

题意：定义一个函数H(e), 如果一条边属于最小生成树，那么H(e) = 0, 如果不属于，那么H(e) = 删掉最少的边使得它是最小生成树的边数

思路：考虑最小生成树任意两点之间都相互连通，那么对于每一条边，我们需要知道这条边邻接的两点，在包含这条边以及权值比这条边小的所有边的图中的最小割是多少，对每一条边都这么跑一次最大流

#include <bits/stdc++.h>

using namespace std;

#define N 110
#define M 510
#define INF 0x3f3f3f3f

struct Edge
{
    int to, nx, cap, flow;
    inline Edge() {}
    inline Edge(int to, int nx, int cap, int flow) : to(to), nx(nx), cap(cap), flow(flow) {}
}edge[M << 1];

int head[N], tol;

inline void Init()
{
    tol = 2;
    memset(head, -1, sizeof head);
}

inline void addedge(int u, int v, int w)
{
    edge[tol] = Edge(v, head[u], w, 0); head[u] = tol++;
    edge[tol] = Edge(u, head[v], w, 0); head[v] = tol++; 
}

int Q[N];
int dep[N], cur[N], sta[N];

inline bool BFS(int s, int t, int n)
{
    int front = 0, tail = 0;
    memset(dep, -1, sizeof (dep[0]) * (n + 2));
    dep[s] = 0;
    Q[tail++] = s;
    while (front < tail)
    {
        int u = Q[front++];
        for (int it = head[u]; ~it; it = edge[it].nx)
        {
            int v = edge[it].to;
            if (edge[it].cap > edge[it].flow && dep[v] == -1)
            {
                dep[v] = dep[u] + 1;
                if (v == t) return true;
                Q[tail++] = v;
            }
        }
    }
    return false;
}

inline int Dinic(int s, int t, int n)
{
    int maxflow = 0;
    while (BFS(s, t, n))
    {
        for (int i = 0; i < n; ++i) cur[i] = head[i];
        int u = s, tail = 0;
        while (cur[s] != -1)
        {
            if (u == t)
            {
                int tp = INF;
                for (int i = tail - 1; i >= 0; --i)
                    tp = min(tp, edge[sta[i]].cap - edge[sta[i]].flow);
                maxflow += tp;
                for (int i = tail - 1; i >= 0; --i)
                {
                    edge[sta[i]].flow += tp;
                    edge[sta[i] ^ 1].flow -= tp;
                    if (edge[sta[i]].cap - edge[sta[i]].flow == 0)
                        tail = i;
                }
                u = edge[sta[tail] ^ 1].to;
            }
            else if (cur[u] != -1 && edge[cur[u]].cap > edge[cur[u]].flow && dep[u] + 1 == dep[edge[cur[u]].to])
            {
                sta[tail++] = cur[u];
                u = edge[cur[u]].to;
            }
            else
            {
                while (u != s && cur[u] == -1)
                    u = edge[sta[--tail] ^ 1].to;
                cur[u] = edge[cur[u]].nx;
            }
        }
    }
    return maxflow;
}

struct node
{
    int u, v, w;
    inline void scan()
    {
        scanf("%d%d%d", &u, &v, &w);
        u--, v--;
    }
    inline bool operator < (const node& r) const
    {
        return w < r.w;
    }
}G[M];

int n, m;

int main()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= m; ++i)
            G[i].scan();
        sort(G + 1, G + 1 + m);
        int ans = 0;
        for (int i = 1; i <= m; ++i)
        {
            Init();
            for (int j = 1; j < i; ++j)
            {
                if (G[j].w >= G[i].w)
                    break;
                addedge(G[j].u, G[j].v, 1);
            }
            ans += Dinic(G[i].u, G[i].v, n);
//            cout << G[i].u << " " << G[i].v << " " << ans << endl;
        }
        cout << ans << endl;
    }    
    return 0;
}

F：philosopher's Walk

题意：给出n=2^k，m<=2^2k。对于一个n*n的图，输出第m个点的坐标。

思路：因为每个n*n的图由4个全等的(n/2)*(n/2)的图组成，所以采用分治的思想，每次算出目标点在4块图的那一块，记录那块图的坐标。

但是因为子图的方向不一样，所以要在计算出第几块图之后，要根据之前的方向判断这块图在左上，左下，右上，右下那个位置。

#include<bits/stdc++.h>

using namespace std;

int main() {
    long long n,m,x,y,t,p,q;
    while (scanf("%lld %lld",&n,&m)!=EOF) 
    {
        x=y=1;    t=1;
        while (n>1) {
            q=n*n/4;
            p=(m-1)/q+1;
            m=(m-1)%q+1;
            if (t==1) {
                if (p==1) {t=2;}
                else if (p==2) {y+=(n/2);}
                else if (p==3) {x+=(n/2); y+=(n/2);}
                else if (p==4) {x+=(n/2); t=4;}
            }
            else if (t==2) {
                if (p==1) {t=1;}
                else if (p==2) {x+=(n/2);}
                else if (p==3) {x+=(n/2); y+=(n/2);}
                else if (p==4) {y+=(n/2); t=3;}
            }
            else if (t==3) {
                if (p==1) {x+=(n/2); y+=(n/2); t=4;}
                else if (p==2) {x+=(n/2);}
                else if (p==4) {y+=(n/2); t=2;}
            }
            else if (t==4) {
                if (p==1) {x+=(n/2); y+=(n/2); t=3;}
                else if (p==2) {y+=(n/2);}
                else if (p==4) {x+=(n/2); t=1;} 
            }
            n/=2;
        }
        printf("%lld %lld
",x,y);
    }
    return 0;
}

G：Rectilinear Regions

留坑。

H：Rock Paper Scissors

留坑。

I：Slot Machines

题意：寻找下标为k长度为p的循环节，使得k+p最小，在k+p相同时保证p小。

思路：倒过来寻找，Next[i]记录上一个和这一位数字相同的下标。每次寻找都找前一位的Next中其中一位，并且保证这一位后面与当前节点值相同，从而保证了Next数组里面记录了循环的初始节点，最后扫一遍即可。

#include<bits/stdc++.h>

using namespace std;

#define N 1000010
#define INF 0x3f3f3f3f

int n;
int arr[N], nx[N];

int main()
{
    while(~scanf("%d",&n))
    {
        memset(nx, 0, sizeof nx);
        for(int i = n; i >= 1; --i)
        {
            scanf("%d", arr + i);
        }
        for(int i = 2; i <= n; ++i)
        {
            int tmp = nx[i - 1];
            while(tmp != 0 && arr[i] != arr[tmp + 1])
                tmp = nx[tmp];
            if(arr[i] == arr[tmp + 1])
                tmp++;
            nx[i] = tmp;
        }
        int sum = INF;
        int ansk = 0;
        int ansp = 0;
        for(int i = 1; i <= n; ++i)
        {
            int k = n - i;
            int p = i - nx[i];
            if(k + p < sum)
            {
                sum = k + p;
                ansk = k;
                ansp = p;
            }
            else if(sum == k + p && p < ansp)
            {
                ansk = k;
                ansp = p;
            }
        }
        printf("%d %d
",ansk, ansp);
    }
    return 0;
}

J：Strongly Matchable

留坑。

K：Untangling Chain

题意：给出n个线段，每次给出线段的长度和转向的方向 1 表示左转，-1 表示右转，可以修改线段的长度,长度为(1 -> n) 使得所有线段不相交

思路： 按照类似这样的方法构造一下，每次的长度最多+1，长度最大为n，符合题意。 图中只是一个方向的实例，构造的图不一定是这样，但是思路是这样。 

#include <bits/stdc++.h>

using namespace std;

int n;

int up, down, l, r;
int x, y, dir;

// 0 up 1 left 2 down 3 right

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        up = down = l = r = 0;
        x = y = dir = 0;
        int len, num;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d%d", &len, &num);
            dir = (dir + 4) % 4;
            if (dir == 0)
            {
                len = up - y + 1;
                y += len;
                up = max(up, y);
            }
            else if (dir == 1)
            {
                len = x - l + 1;
                x -= len;
                l = min(l, x);
            }
            else if (dir == 2)
            {
                len = y - down + 1;
                y -= len;
                down = min(down, y);
            }
            else if (dir == 3)
            {
                len = r - x + 1;
                x += len;
                r = max(r, x);
            }
            printf("%d%c", len , " 
"[i == n]);
            dir += num;
        }
    }
    return 0;
}

J：Vacation Plans

留坑。

---

赛后总结：

• 如果开了某一题但是没有思路，读新题的优先级高于一切
• 比赛过程尽量不要懈怠，不一定无题可做， 不要从心里上战败
• 做题要看清数据范围，算一算时间复杂度，有些题确实可以爆搜
• 写题的时候，如果开了两个一样的东西，一定要万分注意，要知道什么时候用哪个
• 当没有什么思路的时候，模拟一下题意过程是比较好的一个方式
• 一道题如果没有思路，但是感觉像某种算法的题，可以考虑弃题，不要停留太久浪费时间，读新题
• 对于题面又臭又长的题目，一定要耐心下来读
• 当一题队友在敲，但是思维有一点阻碍时，可以适当放下手中事，帮队友理清一下思路可能会更好
• 构造题有时候要大胆，但是构造题以及猜想题没有百分百把握下，不可开场做