第九届山东省ACM大学生程序设计竞赛（部分）

B - Bullet

题意：
$\ \ \ \ n * m$的网格中，不$0$的位置代表该地方有一个怪物，杀死它的经验值是$a_{ij}$，现在每一行每一列最多能杀死一只怪物，而自己得到的经验值是杀死的这些怪物的经验值的最小值，问保证杀死最多怪物的情况下，自己能最多得到多少经验。

思路：
$\ \ \ \ $假设$(i,j)$这个位置有怪物，则$X$部的$i$点向$Y$部的$j$点连一条边，最多能杀死的怪物数量就是最大匹配，经典的二分图匹配。求出最大的数量之后，二分自己能得到的经验值$ans$，把网格中小于$ans$的怪物去除再求二分图匹配，如果最大匹配和最多数量一样，则$ans$可以增大，否则$ans$减小。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 510;
const int INF = 1e6;
using namespace std;

int n, m, mat[maxn][maxn];
int use[maxn], from[maxn];
vector<int> G[maxn];

int dfs(int x) {
    for(int i = 0; i < G[x].size(); i++) {
        int u = G[x][i];
        if(!use[u]) {
            use[u] = 1;
            if(from[u] == -1 || dfs(from[u])) {
                from[u] = x;
                return 1;
            }
        }
    }
    return 0;
}

int maxp() {
    memset(from, -1, sizeof(from));
    int sum = 0;
    for(int i = 1; i <= n; i++) {
        memset(use, 0, sizeof(use));
        sum += dfs(i);
    }
    return sum;
}


const int MAX = 10000;
char buf[MAX], *ps = buf, *pe = buf + 1;
inline void rnext() {
    if(++ps == pe) pe = (ps = buf) + fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool in(T &ans) {
    ans = 0;
    T f = 1;
    if(ps == pe) return false;//EOF
    do{
        rnext();
        if('-' == *ps) f = -1;
    } while(!isdigit(*ps) && ps != pe);
    if(ps == pe) return false;//EOF
    do {
        ans = (ans<<1)+(ans<<3)+*ps-48;
        rnext();
    } while(isdigit(*ps) && ps != pe);
    ans *= f;
    return true;
}

int tot[maxn * maxn], num;

bool build(int ans, int mp) {
    for(int i = 1; i <= n; i++) {
        G[i].clear();
        for(int j = 1; j <= n; j++) {
            if(mat[i][j] < ans) continue;
            G[i].push_back(j);
        }
    }
    int tt = maxp();
    if(tt >= mp) return true;
    else return false;
}

int main() {
    while(in(n)) {
        num = 0;
        for(int i = 1; i <= n; i++) G[i].clear();
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                in(mat[i][j]);
                if(mat[i][j]) {
                    tot[num++] = mat[i][j];
                    G[i].push_back(j);
                }
            }
        }
        int t = maxp();
        if(!t) { printf("0\n"); continue; }
        sort(tot, tot + num);
        num = unique(tot, tot + num) - tot;
        int l = 0, r = num;
        while(l < r) {
            int mid = (l + r) >> 1;
            bool can = build(tot[mid], t);
            if(can) l = mid + 1;
            else r = mid;
        }
        printf("%d\n", tot[r - 1]);
    }
    return 0;
}

D - Dance

题意：
$\ \ \ \ $$n$个节点的树，$0$为根节点(权值为$0$，可选次数没有限制)，每个节点有一个权值$pow$，还有一个可选择次数$num$，你每次可以选择一个叶节点(必须保证叶节点到根节点路径上所有节点的可选次数大于$0$)，这次你得到的权值是叶节点到根节点路径上所有点的权值和，但是同时所有点的可选次数$num$要减$1$，叶节点可以重复选，问最多得到的权值。

思路：
$\ \ \ \ $对每个叶节点，预处理出选它一次能得到的权值和，对它们按得到的权值和从大到
小排个序，每次选得到权值和最大的叶节点，求它到根节点的路径上全部节点最小的
可选次数，一次性取完这个最小可选次数，然后更新路径上的信息。信息可以用树链剖
分维护，树链剖分代码量有点大，就直接写个暴力了。暴力最差是$n^2$，这里好像没有放
卡暴力的数据。还有数据好像有问题，用$!=EOF$输入是错的。。。

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 10;
using namespace std;

typedef pair<ll, int> pa;
int n, m, T, C[maxn];
int pre[maxn], x[maxn], y[maxn];
int l[maxn], r[maxn], dfn[2 * maxn], cnt;
vector<pa> vec;
vector<int> g[maxn];

void dfs(int x, ll tot) {
    dfn[cnt++] = x; l[x] = cnt - 1;
    for(int i = 0; i < g[x].size(); i++) {
        int v = g[x][i];
        dfs(v, tot + y[x]);
    }
    dfn[cnt++] = x; r[x] = cnt - 1;
    if(g[x].size() == 0) vec.push_back(pa(tot + y[x], x));
}

int nxt[2 * maxn], vis[2 * maxn], prv[2 * maxn];
void del(int l, int r) {
    int st = l;
    while(st != nxt[r]) {
        vis[st] = 1;
        st = nxt[st];
    }
    nxt[prv[l]] = nxt[r];
    prv[nxt[r]] = prv[l];
}

int main() {
    scanf("%d", &n);
    vec.clear(); cnt = 1;
    for(int i = 0; i < maxn; i++) g[i].clear();
    memset(vis, 0, sizeof vis);
    memset(pre, 0, sizeof pre);
    for(int i = 1; i <= n; i++) {
        int px; scanf("%d %d %d", &px, &x[i], &y[i]);
        pre[i] = px; g[px].push_back(i);
    }
    dfs(0, 0);
    sort(vec.begin(), vec.end());
    ll ans = 0;
    for(int i = 0; i < cnt; i++) { nxt[i] = i + 1; prv[i + 1] = i; }
    for(int i = vec.size() - 1; i >= 0; i--) {
        int v = vec[i].second;
        ll val = vec[i].first;
        if(vis[l[v]]) continue;
        int num = maxn;
        while(v) { num = min(num, x[v]); v = pre[v]; }
        ans += val * num;
        int u; v = vec[i].second;
        while(v) { x[v] -= num; if(!x[v]) u = v; v = pre[v]; }
        del(l[u], r[u]);
    }
    printf("%lld\n", ans);
    return 0;
}

H - Dominoes

题意：
$\ \ \ \ n \times m$的棋盘，上面铺了一些$1 \times 2$的多米诺骨牌，每个骨牌是不相同的，现在棋盘恰好只留下一个空位，骨牌可以通过空位来移动，问除了当前状态最多能到达多少个不同的状态，答案$mod\ 1e9 + 7$。

思路：
$\ \ \ \ $都是猜的，如果当前空位在$(i,j)$，现在移动到了$(i',j')$，好像除了按照原来的路径返回不能再回到$(i,j)??$，然后到达$(i',j')$棋盘形状相同但是不同骨牌的位置有变化$???$然后记忆化搜索$???$看数据范围应该是行状压啊$??$网上的都是暴力那就是移动形成的状态是树$??$

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e4 + 10;
const int INF = 1e6;
const int mod = 1e9 + 7;
using namespace std;

int mat[13][maxn];
int dp[13][maxn], now[13][maxn];
int vis[13][maxn];
int n, m, k;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dir[] = {1, 0, 3, 2};
int _flag[] = {0, 0, 1, 1};
int x[maxn * 15], y[maxn * 15], flag[maxn * 15];
int X[maxn * 15], Y[maxn * 15];

int dfs(int dr, int x, int y) {
    int &ans = dp[x][y];
    if(ans != -1) return ans;
    ans = 1;
    for(int i = 0; i < 4; i++) {
        int nx = x + dx[i], ny = y + dy[i];
        if(nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
        if(dir[i] == dr || flag[now[nx][ny]] != _flag[i]) continue;
        int nnx = nx + dx[i], nny = ny + dy[i];
        now[x][y] = now[nnx][nny]; now[nnx][nny] = 0;
        ans += dfs(i, nnx, nny);
        if(ans >= mod) ans -= mod;
        now[nnx][nny] = now[x][y]; now[x][y] = 0;
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(0);
    while(cin >> n >> m >> k) {
        memset(vis, 0, sizeof vis);
        memset(dp, -1, sizeof dp);
        for(int i = 1; i <= k; i++) {
            cin >> x[i] >> y[i] >> X[i] >> Y[i];
            x[i]--; y[i]--; X[i]--; Y[i]--;
            if(x[i] == X[i]) flag[i] = 0; ///横的
            else flag[i] = 1;
            vis[x[i]][y[i]] = 1;
            vis[X[i]][Y[i]] = 1;
            now[x[i]][y[i]] = i;
            now[X[i]][Y[i]] = i;
        }
        int sx = -1, sy = -1;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(!vis[i][j]) { sx = i; sy = j; break; }
            }
            if(~sx) break;
        }
        int ans = dfs(-1, sx, sy);
        ans--; if(ans < 0) ans += mod;
        printf("%d\n", ans);
    }
    return 0;
}