BUPT2017 springtraining(16) #3 ——搜索与动态规划

题目在这里啊

A.最长上升子序列，范围很小所以写了简单的O(n^2)算法

#include <iostream>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

int n, m, a[], f[];

int main() {
    ios::sync_with_stdio(false);
    cin >> n;
    rep(i, , n) cin >> a[i];
    rep(i, , n) {
        f[i] = ;
        rep(j, , i - ) {
            if(a[j] < a[i])
                f[i] = max(f[i], f[j] + );
        }
    }
    rep(i, , n) m = max(m, f[i]);
    cout << m;
    return ;
}

B.Sum( C[i] * G[i] ) = 0 的方案数嘛

就是个分组背包问题嘛，O(n^2 * m^2 * max_weight)

#include <iostream>
#include <cstdio>

using namespace std;

int n, m, x, y, s, t, a[], f[][];

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m, f[][] = ;
    for(int i = ;i <= n;i ++)
        cin >> a[i], a[i] += ;
    for(int i = ;i <= m;i ++) {
        cin >> x, s += x;
        for(int j = ;j <= n;j ++) {
            y = x * a[j];
            for(int k = ;k >= y;k --) {
                f[i][k] += f[i - ][k - y];
            }
        }
    }
    printf("%d\n", f[m][s * ]);
    return ;
}

C.就是个阶乘+组合数，合在一起或者分开算都是ok的

不到30其实就能爆掉longlong了...题目保证不爆了就不管了

对，初始化请不要忘记有 k = 0

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

ll b[], a[][];

int t, n, k;

int main() {
    ios::sync_with_stdio(false);
    a[][] = b[] = b[] = ;
    rep(i, , ) a[i][] = ;
    rep(i, , ) {
        b[i] = b[i - ] * i;
        rep(j, , i)
            a[i][j] = a[i - ][j - ] + a[i - ][j];
    }
    cin >> t;
    rep(i, , t) {
        cout << "Case "<< i <<": ";
        cin >> n >> k;
        cout << a[n][k] * a[n][k] * b[k] << endl;
    }
    return ;
}

D.回文串好多都是区间DP

f[i][j]代表从 i 到j 这段区间能弄出多少种回文串

其实我的DP转移方程是对着样例数据YY出来的...

if(s[i] == s[j]) f[i][j] = f[i + 1][j] + f[i][j - 1] + 1

else f[i][j] = f[i + 1][j] + f[i][j - 1] - f[i + 1][j - 1]

因为不满足 s[i] == s[j] 的话，那样子加就会重复计算，所以需要减去重复部分

否则的话，因为这段区间两边字母相同

所以就可以在它们中间夹上f[i + 1][j - 1]种回文串(所以不用减重复

另外也可以什么都不加，所以还要 +1

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

int main() {
    ios::sync_with_stdio(false);
    int t;
    ll f[][];
    string s;
    cin >> t;
    for(int i = ;i <= t;i ++) {
        cin >> s;
        memset(f, , sizeof f);
        for(int j = ;j < s.size();j ++) f[j][j] = ;
        for(int d = ;d < s.size();d ++)
            for(int j = ;j + d < s.size();j ++) {
                int k = j + d;
                if(s[j] == s[k]) f[j][k] = f[j + ][k] + f[j][k - ] + ;
                else f[j][k] = f[j + ][k] + f[j][k - ] - f[j + ][k - ];
            }
        cout << "Case " << i << ": " << f[][s.size() - ] << endl;
    }
    return ;
}

E.我说Floyed你就会了吧，这就很有灵性！

#include <iostream>
#include <cstring>
#include <cstdio>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

string s;

bool f[][];

int main() {
    ios::sync_with_stdio(false);
    while(cin >> s) {
        if(s[] == '') {
            rep(k, , )
                rep(i, , )
                    rep(j, , )
                        f[i][j] |= f[i][k] & f[k][j];
            puts(f[][] ? "Yes." : "No.");
            memset(f, , sizeof f);
        }
        else f[s[] - 'a'][*(s.end() - ) - 'a'] = ;
    }
    return ;
}

F.不存在任何一条路径上有两点颜色相同...

n*m的矩阵，路径固定长度为n + m - 1，所以n + m - 1 > k 就不存在方案

...所以n , m <= 1000完全开玩笑的

直观来看最坏情况就是在5 * 6的矩阵里

我们考虑爆搜+检验，O(10 ^ 30 * n * m)

1. 优化一下，压位来记录前 [ i *  j ] 矩阵（不含a[i][j]）里用过的颜色

来确定a[i][j]的可选颜色，然后这样大概在O(10 ^ 20)

2.再优化一下，如果前 [ i *  j ] 矩阵（不含a[i][j]）里用过的颜色数为 C

那么剩下部分（含a[i][j]）最少需要颜色数 D = n - i + m - j - 1 + 2

如果 C + D > k 那么当前方案是不可能有解的， 这样大概 O(玄学)

当然仍过不了5 * 6 矩阵初始全空的情况

3.再优化一下，当前位置如果染色为 p 或 q

这两种颜色都是第一次被使用

即之前的dfs中染过色的以及初始就被染色的部分都没使用过这两种颜色

那么我们可以认为这两种颜色是等价的

换句话说就是当前位置染色为 p 再dfs下去

和当前位置染色为 q 再dfs下去对答案的贡献是一样的

所以可以只算一个，另一个直接加上就可以了

这时候效率O(玄学 --), 5 * 6 矩阵初始全空的情况已经能过了...

大力交一发能过了...15ms很快乐

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int Mod = 1e9 + ;

int n, m, k, a[][];

int used[], g[][], f[][];

ll dfs(int x, int y) {
    if(y > m) x ++, y = ;
    if(x > n) return ;
    int z = __builtin_popcount(g[x][y] = g[x - ][y] | g[x][y - ]);
    if(z + n - x + m - y +  > k) return ;
    ll ret = , tmp = -;
    if(!a[x][y]) {
        for(int i = ;i <= k;i ++) {
            if((g[x][y] | f[x][y]) & ( << i)) continue;
            used[i] ++, g[x][y] |= ( << i);
            if(used[i] == ) {
                if(tmp == -) tmp = dfs(x, y + );
                ret += tmp;
            }
            else {
                ret += dfs(x, y + );
            }
            used[i] --, g[x][y] ^= ( << i);
        }
    }
    else {
        g[x][y] |= ( << a[x][y]);
        ret = dfs(x, y + );
    }
    return ret % Mod;
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n >> m >> k;
    if(n + m -  > k) {
        puts("");
        return ;
    }
    for(int i = ;i <= n;i ++)
        for(int j = ;j <= m;j ++) {
            cin >> a[i][j];
            if(a[i][j]) used[a[i][j]] ++;
        }
    for(int i = n;i;i --)
        for(int j = m;j;j --) {
            if(a[i][j] && ((f[i + ][j] | f[i][j + ]) & ( << a[i][j]))) {
                puts("");
                return ;
            }
            f[i][j] = f[i + ][j] | f[i][j + ] | ( << a[i][j]);
        }
    cout << dfs(, ) % Mod << endl;
    return ;
}

G.结论题啦

3次bfs找到一条树的直径两个端点 s t

然后ans[i] = max( dis(i, s) , dis(i, t) )

#include <bits/stdc++.h>

#define rep(i, j, k) for(int i = j;i < (k + 1);i ++)

#define rev(i, j, k) for(int i = j;i >= k;i --)

using namespace std;

typedef long long ll;

int n, st, en, vis[], dis[][];

vector <pair<int, int> > e[];

queue <int> q;

void bfs(int s, int t) {
    static int u;en = ;
    memset(dis[t], , sizeof dis[t]);
    memset(vis, -, sizeof vis);
    q.push(s), vis[s] = t;
    while(!q.empty()) {
        u = q.front(), q.pop();
        rep(i, , e[u].size() - )
            if(t != vis[e[u][i].first] && dis[t][e[u][i].first] < dis[t][u] + e[u][i].second) {
                dis[t][e[u][i].first] = dis[t][u] + e[u][i].second;
                q.push(e[u][i].first), vis[e[u][i].first] = t;
            }
    }
    rep(i, , n) if(dis[t][i] > en) en = dis[t][i], st = i;
}

int main() {
    int u, v;
    ios::sync_with_stdio(false);
    while(cin >> n) {
        rep(i, , n) e[i].clear();
        rep(i, , n) cin >> u >> v,
            e[i].push_back(make_pair(u, v)), e[u].push_back(make_pair(i, v));
        bfs(, ), bfs(st, ), bfs(st, );
        rep(i, , n) cout << max(dis[][i], dis[][i]) << endl;
    }
    return ;
}

H.显然所有环都需要1次变成树

然后再数出树的数量，再并到一棵树上

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const int maxn = ;

vector <int> e[maxn];

int n, m, f[maxn], v[maxn], root[maxn];

void dfs1(int x) {
    v[x] = ;
    for(int i = ;i < e[x].size();i ++)
        if(e[x][i] != x) dfs1(e[x][i]);
}

int dfs2(int x, int t, int y = ) {
    if(v[x] == t) return ;
    else if(v[x] !=  && v[x] != t) return ;
    v[x] = t;
    for(int i = ;i < e[x].size();i ++)
        y |= dfs2(e[x][i], t);
    return y;
}

int main() {
    ios::sync_with_stdio(false);
    cin >> n;
    for(int i = ;i <= n;i ++) cin >> f[i], e[f[i]].push_back(i);
    for(int i = ;i <= n;i ++)
        if(f[i] == i)
            dfs1(i), root[++ root[]] = i, m = ;
    for(int i = ;i <= n;i ++)
        if(!v[i] && dfs2(i, i))
            root[++ root[]] = i;
    if(m) {
        cout << root[] -  << endl;
        for(int i = ;i <= root[];i ++)
            f[root[i]] = root[];
        for(int i = ;i <= n;i ++)
            cout << f[i] << " ";
    }
    else {
        cout << root[] << endl;
        for(int i = ;i <= root[];i ++)
            f[root[i]] = root[];
        for(int i = ;i <= n;i ++)
            cout << f[i] << " ";
    }
    return ;
}

I.转一下能不能转好，一共就只有12种转法...

除去顺时针和逆时针就是6种，枚举一下再验证吧

#include <iostream>
#include <cstdio>

#define rep(i, j, k) for(int i = j;i <= k;i ++)

using namespace std;

int f[][] = {
    , , , , , , , ,
    , , , , , , , ,
    , , , , , , , ,
    , , , , , , , ,
    , , , , , , , ,
    , , , , , , ,
};

bool judge(int *a) {
    for(int i = ;i < ;i += )
        if(!(a[i] == a[i + ] && a[i] == a[i + ] && a[i] == a[i + ]))
            return ;
    return ;
}

bool ok(int *a, int *b, int ret = ) {
    static int c[];
    rep(i, , ) c[i] = c[i + ] = a[b[i]];
    rep(i, , ) a[b[i]] = c[i + ];
    ret |= judge(a);
    rep(i, , ) a[b[i]] = c[i + ];
    ret |= judge(a);
    rep(i, , ) a[b[i]] = c[i];
    return ret;
}

int main() {
    ios::sync_with_stdio(false);
    int n, m, a[];
    cin >> n;
    rep(i, , n) {
        rep(i, , ) cin >> a[i];m = judge(a);
        rep(i, , ) if(ok(a, f[i])) m = ;
        puts(m ? "YES" : "NO");
    }
    return ;
}

J.一个简单的剪枝暴搜...

因为要满足同一行同一列同一区域只出现一次...

所以预处理一下就行了，压不压位随意吧...

WA了1h发现是dfs函数最后忘记写return 0...

很多地方会默认return 1所以不报编译错误...

这个时候vs大法就很舒服了...

虽然给你带个安全套，但是提醒肯定会提醒的！

#include <iostream>
#include <algorithm>

using namespace std;

int k, a[][], b[], c[], d[];

pair<int, int> p[];

bool dfs(int n) {
    if(n > k) {
        for(int i = ;i < ;i ++) {
            for(int j = ;j < ;j ++)
                printf("%d ", a[i][j]);
            printf("%d\n", a[i][]);
        }
        return ;
    }
    int x = p[n].first, y = p[n].second, z = x /  *  + y / ;
    for(int i = ;i <= ;i ++) {
        if((b[x] | c[y] | d[z]) & ( << i)) continue;
        a[x][y] = i;
        b[x] ^=  << i;
        c[y] ^=  << i;
        d[z] ^=  << i;
        if(dfs(n + )) return ;
        b[x] ^=  << i;
        c[y] ^=  << i;
        d[z] ^=  << i;
    }
    return ;
}

int main() {
    ios::sync_with_stdio(false);
    int i, j, flag = ;
    char str[];
    while(cin >> str) {
        if(flag ++) puts("");
        for(i = ;i < ;i ++) b[i] = c[i] = d[i] = ;
        i = , j = , k = ;
        if(str[] == '?') a[i][j] = -, p[++ k] = make_pair(i, j);
        else a[i][j] = str[] - '', b[] |=  << a[i][j], c[] |=  << a[i][j], d[] |=  << a[i][j];
        for(j ++;i < ;i ++) {
            for(;j < ;j ++) {
                cin >> str;
                if(str[] == '?') a[i][j] = -, p[++ k] = make_pair(i, j);
                else a[i][j] = str[] - '', b[i] |=  << a[i][j], c[j] |=  << a[i][j], d[i /  *  + j / ] |=  << a[i][j];
            }
            j = ;
        }
        dfs();
    }
    return ;
}

题外话:

日常被自己的ios::sync_with_stdio坑...

会取消cin和scanf，cout和printf的同步

所以一旦开了这玩意儿就绝对不能混用了！

当然开了这玩意儿后，cin几乎是绝对比scanf好用的

因为我们很少需要格式化读入的骚操作

而cout和printf各有利弊吧

简单输出cout仍然是比printf方便的

而格式化输出的话，printf更舒服

至于puts似乎是跟printf一路的吧...

不好好训练脑子就要锈死了...