bupt summer training for 16 #7 ——搜索与DP

https://vjudge.net/contest/174962#overview

A.我们发现重点在于x，y只要累加就ok了

在每个x上只有上下两种状态，所以可以记忆化搜索

f[0/1][i]表示 x = i 时向下/上走，那需要移动多少才能走出去

#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 500010;

typedef long long ll;

ll a[maxn], f[2][maxn];

int n, b[2][maxn], vis[2][maxn];

ll dfs(int i, int k, ll d = 0) {
    if(vis[k][i]) {
        b[k][i] = -1;
        return f[k][i] = 0;
    }
    vis[k][i] = 1;
    if(!f[k][i]) {
        int y = i + (k ? a[i] : -a[i]);
        if(y > n || y <= 1) d = 0;
        else d = dfs(y, k ^ 1);
        f[k][i] = d + a[i];
        if(y >= 1 && y <= n && b[k ^ 1][y]) b[k][i] = -1;
    }
    vis[k][i] = 0;
    return f[k][i];
}

int main() {
    scanf("%d", &n);
    for(int i = 2;i <= n;i ++)
        scanf("%I64d", &a[i]);
    b[0][1] = b[1][1] = -1;
    for(int i = 2;i <= n;i ++)
        dfs(i, 0), dfs(i, 1);
    for(int i = 1;i < n;i ++) {
        if(b[0][1 + i]) puts("-1");
        else printf("%I64d
", i + f[0][1 + i]);
    }
    return 0;
}

写狗了又RE又T又WA的...写的丑陋，我。无法忍受

B.非常无脑的爆搜，效率玄学

数据范围个位数还是可以大胆以下的

#include <cstdio>
#include <algorithm>

using namespace std;

const int xx[] = {-1, 1, 0, 0};
const int yy[] = {0, 0, 1, -1};

int n, m, k;

char s[10][10];

bool vis[10][10];

bool dfs(const int &x, const int &y, const int &cc) {
    if(cc == k) return 1;
    int nx, ny;
    for(int i = 0;i < 4;i ++) {
        nx = x + xx[i], ny = y + yy[i];
        if(nx > 0 && nx <= n && ny > 0 && ny <= m && s[nx][ny] != 'S' && !vis[nx][ny]) {
            vis[nx][ny] = 1;
            if(dfs(nx, ny, cc + 1)) return 1;
            vis[nx][ny] = 0;
        }
    }
    return 0;
}

int main() {
    while(scanf("%d %d", &n, &m), n!= 0) {
        k = 0;
        for(int i = 1;i <= n;i ++) {
            scanf("%s", s[i] + 1);
            for(int j = 1;j <= m;j ++)
                vis[i][j] = 0, k += (s[i][j] != 'S');
        }
        vis[1][1] = 1;
        puts(dfs(1, 1, 1) ? "YES" : "NO");
    }
    return 0;
}

C.显而易见的树型DP，依旧写的很糟...

f[i][j]表示从节点 i 向下走距离 j 能获得的最大价值

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;

int n, m, s, a[110], f[110][110], g[110][110];

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

void dfs(int u, int fa) {
    int v, w, i;
    for(i = 0;i <= m;i ++) g[u][i] = 0;
    for(i = 0;i < e[u].size();i ++) {
        v = e[u][i].first;
        if(v == fa) continue;
        w = e[u][i].second;
        dfs(v, u);
        for(int j = m;j >= 0;j --)
            for(int k = j;k >= 0;k --)
                if(j - k - w >= 0) 
                    f[u][j] = max(f[u][j], g[u][k] + f[v][j - k - w]);
        for(int j = 0;j <= m;j ++)
            g[u][j] = f[u][j];
    }
    for(i = 0;i <= m;i ++) f[u][i] += a[u];
}

int main() {
    while(~scanf("%d", &n)) {
        memset(f, 0, sizeof f);
        memset(g, 0, sizeof g);
        memset(e, 0, sizeof e);
        for(int i = 1;i <= n;i ++)
            scanf("%d", &a[i]);
        for(int u, v, w, i = 1;i < n;i ++) {
            scanf("%d %d %d", &u, &v, &w);
            e[u].push_back(make_pair(v, w));
            e[v].push_back(make_pair(u, w));
        }
        scanf("%d %d", &s, &m), m /= 2;
        dfs(s, s);
        printf("%d
", f[s][m]);
    }
    return 0;
}

D.大家都会写大龙虾算法让我有些惶恐...

于是决定抄一发队友的dlx板子