CTU Open 2013

/*
Fractional Lotion

题意：给出 n ,求有多少对 (x, y)，满足 1/x + 1/y = 1/n。

分析：式子变换一下，y = nx / (x-n)，由于 n <= 10000, y > 0, 而且由于 x 和 y 没有顺

序限制，即 (x, y) 和 (y, x) 为同一种情况，所以 x 的枚举范围为 n < x <= 2n
*/
代码：
#include<bits/stdc++.h>
using namespace std;

int main() {
    int o, n, x, ans;
    while(scanf("%d/%d", &o, &n) != EOF) {
        x = n << 1;
        ans = 0;
        while(x > n) {
            if(n * x % (x - n) == 0) {
                ans++;
            }
            x--;
        }
        printf("%d\n", ans);
    }
    return 0;
}

/*
Folded Map

题意：给出一个 Ar X Ac 的图，要求用最少的 Tr X Tc 的矩形 R 覆盖所有的 'X'，问最少要多少个这样的矩形。

分析：有一个简单又巧妙地做法。

首先把边界 Ar、Ac 扩大至 Ar+Tr、Ac+Tc，然后用一个数组cnt_tile[i][j]表示右下角为(i, j)的矩形R所覆盖的 'X' 的数量，那么我们可以

枚举{ (x, y) | (0 <= x < Tr && 0 <= y < Tc) }中的点作为铺矩形的起点，然后模拟铺矩形的行为，铺满整个图，统计 (cnt_tile[x][y] > 

0) 的数目，即有覆盖到'X'的矩形，即是所需矩形的数目，所有的起点都试一遍取最优值即可。具体参见代码，很好理解。
PS: cnt_tile[][]数组的实现方法有很多，可以用代码里的方法扫描全图得到，也可以用前缀和等方法。
*/
代码：
#include<bits/stdc++.h>
using namespace std;
const int N = 1111;
bool data[N][N];
int cnt_left[N][N], cnt_tile[N][N];
int ar, ac, tr, tc;

int cal(int x, int y) {
    int ret = 0;
    for(int i = x; i < ar + tr; i += tr) {
        for(int j = y; j < ac + tc; j += tc) {
            if(cnt_tile[i][j]) { ret++; }
        }
    }
    return ret;
}

int main() {
    char ch;
    int ans, cnt;
    //freopen("in.txt", "r", stdin);
    while(scanf("%d%d%d%d", &ar, &ac, &tr, &tc) != EOF) {
        for(int i = 0; i < ar; i++) {
            getchar();
            for(int j = 0; j < ac; j++) {
                ch = getchar();
                data[i][j] = (ch == 'X');
            }
        }

        for(int i = 0; i < ar + tr; i++) {
            cnt = 0;
            for(int j = 0; j < ac + tc; j++) {
                if(i < ar && j < ac && data[i][j]) cnt++;
                if(j - tc >= 0 && i < ar && data[i][j - tc]) {
                    cnt--;
                }
                cnt_left[i][j] = cnt;
            }
        }

        for(int j = 0; j < ac + tc; j++) {
            cnt = 0;
            for(int i = 0; i < ar + tr; i++) {
                cnt += cnt_left[i][j];
                if(i - tr >= 0 && cnt_left[i - tr][j]) {
                    cnt -= cnt_left[i - tr][j];
                }
                cnt_tile[i][j] = cnt;
            }
        }

        ans = N * N;
        for(int i = 0; i < tr; i++) {
            for(int j = 0; j < tc; j++) {
                ans = min(ans, cal(i, j));
            }
        }

        printf("%d\n", ans);
    }
    return 0;
}

/*
Furry Nuisance

题意：给出一个n个点m条边的图，问能不能通过移除一些点和一些边得到一个只有4个度为1的节点的连通图。

分析：如果比较熟悉bfs，应该很容易想到。bfs是从起点开始然后逐层拓展的，那么可以从图的任意一点进行bfs，若当拓展层的节点数 + 不能

再拓展的点的数量 >= 4，那必定可以通过删除一些点和边得到一个只有4个度为1的节点的连通图。需要注意的是如果从度为1的点开始bfs的话

，那么该点必定可以加到所求的连通图上，这时候只要拓展层的节点数 + 不能再拓展的点的数量 >= 3即可。
*/
代码：
#include<bits/stdc++.h>
using namespace std;
const int N = 10001;
const int M = 40004;
int n, m, d[N];
bool vis[N];
vector<int>edge[M];

bool bfs(int s, int min_cnt) {
    vis[s] = true;
    queue<int>q[2];
    q[0].push(s);
    int x, y, si, lef = 0;
    while(!q[0].empty()) {
        swap(q[0], q[1]);
        while(!q[1].empty()) {
            x = q[1].front();
            q[1].pop();
            si = edge[x].size();
            bool inq = false;
            for(int i = 0; i < si; i++) {
                y = edge[x][i];
                if(!vis[y]) {
                    inq = true;
                    vis[y] = true;
                    q[0].push(y);
                }
            }
            if(!inq) lef++;
        }
        //cout << q[0].size() + lef << ' ' << min_cnt << endl;
        if(q[0].size() + lef >= min_cnt) {
            return true;
        }
    }
    return false;
}

int main() {
    int x, y;
    while(scanf("%d%d", &n, &m) != EOF) {
        for(int i = 1; i <= n; i++) {
            edge[i].clear();
            vis[i] = false;
            d[i] = 0;
        }
        for(int i = 0; i < m; i++) {
            scanf("%d%d", &x, &y);
            edge[x].push_back(y);
            edge[y].push_back(x);
            d[x]++;
            d[y]++;
        }
        bool flag = false;
        for(int i = 1; i <= n; i++) {
            if(!vis[i]) {
                if(bfs(i, 4 - (d[i] == 1))) {
                    flag = true;
                    break;
                }
            }
        }
        if(flag) { puts("YES"); }
        else { puts("NO"); }
    }
    return 0;
}

/*
Fence Orthogonality

题意：给出n个点，用一个周长最小的矩形覆盖所有点，输出矩形的周长。

分析：几何题，凸包 + 旋转卡壳。

如果不知道这两个东西的话，可以看下这下面这里
Graham扫描求凸包算法：
http://blog.csdn.net/tmljs1988/article/details/7259331

如果还不懂，这些讲解视频也是不错的：
http://v.baidu.com/v?word=graham+%E5%87%B8%E5%8C%85&ct=301989888&rn=20&pn=0&db=0&s=0&fbl=800&ie=utf-8

旋转卡壳详解：http://blog.csdn.net/hanchengxi/article/details/8639476

参考代码：
http://blog.csdn.net/wsx1754175/article/details/19355205
*/

/*
Flower Pots

题意：给出12种不同的5连块，分别由12个字母表示，给出4个5连块，前两个为一组，后两个为一组，问能不能拼出两个一样的图案。注意不能

跨组！只能同组内拼，可以旋转也可以翻转。

分析：感觉是很麻烦的模拟和搜索。。。待解决
*/

/*
Frustrated Queue

题意：给出一个由点和括号组成的偶数长度的字符串，每一个字符代表一个人，他们在排队上厕所。已知上厕所的费用为0.5元，等待的人中有

一半带有0.5元的硬币，另一半有1元的硬币。左括号表示当前位置的人只有0.5元的硬币，右括号表示当前位置的人只有1元的硬币，点则表示为

两种情况之一，刚开始厕所管理员是没有任何硬币的，问有多少种不会出现堵塞的序列，输出方案数后6位。

)....... 是必定会堵塞的，因为第一位只有1元的硬币，管理员没办法给他找钱。

分析：DP，dp[i][j]表示前i个人中，其中有j个人带有0.5元硬币的合法方案数。
设 dp[0][0] = 1;
那么当 s[i] == '('时，dp[i][j] = dp[i-1][j-1];
    当 s[i] == ')'时，dp[i][j] = dp[i-1][j];
    当 s[i] == '.'时，dp[i][j] = dp[i-1][j-1] + dp[i-1][j];

第二层循环j可以从(i+1)/2开始枚举，因为前i和人中至少有一半人有0.5元的硬币才可能存在合法情况。
*/
代码：
#include<bits/stdc++.h>
using namespace std;

const int m = 1e6;
char s[2000];
int dp[1001][501];

int main() {
    while(scanf("%s", s + 1) != EOF) {
        int n = strlen(s + 1);
        dp[0][0] = 1;
        for(int i = 1; i <= n; i++) {
                for(int j = (i + 1) / 2; j <= i && j <= n / 2; j++) {
                    if(s[i] == '.') {
                        dp[i][j] = (dp[i-1][j] + dp[i-1][j-1]) % m;
                    }
                    else if(s[i] == '(') {
                        dp[i][j] = dp[i-1][j-1] % m;
                    }
                    else
                        dp[i][j] = dp[i-1][j] % m;
                }
        }
        printf("%d\n", dp[n][n/2]);
    }
    return 0;
}

/*
Frozen Rose-Heads

题意：给出一个n个节点的树和一个起点c，树上的每条边都带有一个权值表示删除这条边的花费，要求用最少花费删除一些边使得节点c和所有

的叶子节点都不连通，输出最小花费。

分析：一眼看过去，就是一道裸的最大流。只要构建一个汇点t连向所有叶子节点，然后求这个图c到t的最大流即可。但是由于这是一颗树，没

有那么复杂，所以也可以用dfs做，可以从c点出发对树进行后序遍历，之后不断把最优值返回到父亲节点就行了，具体参见代码。
*/
代码：
#include<bits/stdc++.h>
using namespace std;

#define v first
#define w second
const int inf = 0x3f3f3f3f;
typedef pair<int,int> pii;
vector<pii>edge[1001];
bool vis[1001];

int dfs(int u, int par) {
    vis[u] = true;
    int son = 0;
    vector<pii>::iterator p;
    for(p = edge[u].begin(); p != edge[u].end(); ++p) {
        if(!vis[p->v]) {
            son += dfs(p->v, p->w);
        }
    }
    if(!son) return par;
    return min(par, son);
}

int main() {
    int n, s, u, v, w;
    while(scanf("%d%d", &n, &s) != EOF) {
        for(int i = 1; i <= n; i++) {
            edge[i].clear();
            vis[i] = false;
        }
        for(int i = 1; i < n; i++) {
            scanf("%d%d%d", &u, &v, &w);
            edge[u].push_back(pii(v, w));
            edge[v].push_back(pii(u, w));
        }
        printf("%d\n", dfs(s, inf));
    }
    return 0;
}

/*
False Sense of Security

题意：就是根据给出的编码表把给出的字符串翻译，然后得到一个点和下划线组成的字符序列和一个长度序列，把长度序列翻转，再按照这个长

度序列把字符序列翻译成另一个字符串，输出这个字符串。

分析：打表模拟。
*/
代码：
略