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 = ;

 typedef long long ll;

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

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

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

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

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

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

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

 #include <cstdio>
 #include <algorithm>

 using namespace std;

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

 int n, m, k;

 char s[][];

 bool vis[][];

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

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

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

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

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

 using namespace std;

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

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

 void dfs(int u, int fa) {
     int v, w, i;
     for(i = ;i <= m;i ++) g[u][i] = ;
     for(i = ;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 >= ;j --)
             for(int k = j;k >= ;k --)
                 if(j - k - w >= )
                     f[u][j] = max(f[u][j], g[u][k] + f[v][j - k - w]);
         for(int j = ;j <= m;j ++)
             g[u][j] = f[u][j];
     }
     for(i = ;i <= m;i ++) f[u][i] += a[u];
 }

 int main() {
     while(~scanf("%d", &n)) {
         memset(f, , sizeof f);
         memset(g, , sizeof g);
         memset(e, , sizeof e);
         for(int i = ;i <= n;i ++)
             scanf("%d", &a[i]);
         for(int u, v, w, i = ;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 /= ;
         dfs(s, s);
         printf("%d\n", f[s][m]);
     }
     return ;
 }

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

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