#333. 【NOIP2017】宝藏

#333. 【NOIP2017】宝藏

http://uoj.ac/problem/333

1、错误的$n^42^n$做法：

dp[s]表示当前的点集为s，然后从这些点中选一个做起点i，然后枚举边，然后更新dp[t|(1<<j)]。dis[s][i]表示点集为s的情况下的i号点的深度。详见代码。

为什么是错的，不满足当前最优一定是最后最优。比如下面的hack数据，正确答案应该是10420，即从4号点出发，长度为1的那条边不要。而在上面的dp中，点集为234的状态中只能从24和34转移而来，而这两个取最小值的时候，一定会算上1这条边，答案为12，而不是10这条边。导致下一步dp的时候，深度边长，导致更不优。

 #include<cstdio>
 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cctype>
 #include<cmath>
 #include<set>
 #include<queue>
 #include<vector>
 #include<map>
 #include<bitset>
 using namespace std;
 typedef long long LL;

 //char buf[100000], *p1 = buf, *p2 = buf;
 //#define nc() p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++

 inline int read() {
     int x = , f = ; char ch = getchar(); for (; !isdigit(ch); ch = getchar()) if (ch=='-') f = -;
     for (; isdigit(ch); ch = getchar()) x = x *  + ch - ''; return x * f;
 }

 const int N = ;
 const LL LLINF = 1e18;
 const int INF = 1e9;

 LL dp[( << ) + ];
 int mp[N][N], dis[( << ) + ][];
 int n, m;

 LL solve(int x) {
     memset(dis, , sizeof(dis));
     int S = ( << n) - ;

     for (int s = ; s <= S; ++s) dp[s] = LLINF;
     dis[ << x][x] = , dp[ << x] = ;

     for (int s = , t; s <= S; ++s) { // 点集
         if (dp[s] == LLINF) continue;
         cout << bitset<>(s) << "\n";
         for (int i = ; i < n; ++i) { // 选一个点当起点
             if (!((s >> i) & )) continue;
             for (int j = ; j < n; ++j) { // 到达的下一个点
                 if (i == j || mp[i][j] == INF || ((s >> j) & )) continue;
                 t = s | ( << j);
                 cout << bitset<>(t) << "\n";
                 if (dp[t] > dp[s] + dis[s][i] * mp[i][j]) {
                     dp[t] = dp[s] + dis[s][i] * mp[i][j];
                     for (int k = ; k < n; ++k) dis[t][k] = dis[s][k];
                     dis[t][j] = dis[s][i] + ;
                     cout << dp[t] << "\n";
                 }
             }
         }
     }
     return dp[S];
 }

 int main() {
 //    freopen("1.txt", "r", stdin);
 //    freopen("2.txt", "w", stdout);
     n = read(), m = read();

     for (int i = ; i <= n; ++i)
         for (int j = ; j <= n; ++j) mp[i][j] = INF;
     for (int i = ; i <= m; ++i) {
         int u = read() - , v = read() - , w = read();
         mp[u][v] = min(mp[u][v], w), mp[v][u] = min(mp[v][u], w);
     }

     LL ans = 1e18;
     for (int i = ; i < n; ++i)
         ans = min(ans, solve(i));
     cout << ans;

     return ;
 }
 /*

 hack数据：
 dp不满足，当前最优，不满足最后的答案最优

 6 14
 1 2 101
 1 3 44
 1 4 235
 1 6 629
 2 3 60
 2 4 196
 2 5 250
 2 6 490
 3 4 237
 3 5 114
 3 6 715
 4 5 166
 4 6 432
 5 6 932

 6 6
 1 2 100
 2 3 1
 2 4 10
 3 4 10
 3 5 100
 4 6 10000

 */

2、那么解决上述dp中出现的dp，就需要按深度进行dp，每次枚举下一深度的所有点，子集dp。复杂度$n^33^n$

 #include<cstdio>
 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cctype>
 #include<cmath>
 #include<set>
 #include<queue>
 #include<vector>
 #include<map>
 #include<bitset>
 using namespace std;
 typedef long long LL;

 inline int read() {
     int x = , f = ; char ch = getchar(); for (; !isdigit(ch); ch = getchar()) if (ch=='-') f = -;
     for (; isdigit(ch); ch = getchar()) x = x *  + ch - ''; return x * f;
 }

 const int N = ;
 const LL LLINF = 1e18;
 const int INF = 1e9;

 LL dp[( << ) + ][], tmp[( << ) + ], dis[N];
 int mp[N][N];
 int n, m;

 LL solve(int x) {
     int S = ( << n) - ;
     for (int s = ; s <= S; ++s)
         for (int i = ; i <= n; ++i) dp[s][i] = LLINF;
     dp[ << x][] = ;

     for (int s = ; s <= S; ++s) {
         int r = ;
         for (int i = ; i < n; ++i) dis[i] = LLINF;
         for (int i = ; i < n; ++i) {
             if ((s >> i) & )
                 for (int j = ; j < n; ++j)
                     if (!((s >> j) & ) && mp[i][j])
                         r |= ( << j), dis[j] = min(dis[j], (LL)mp[i][j]);
         }
         for (int t = r; t; t = (t - ) & r) {
             tmp[t] = ;
             for (int i = ; i < n; ++i)
                 if ((t >> i) & ) tmp[t] += dis[i];
         }
         for (int d = ; d <= n; ++d) {
             if (dp[s][d] == LLINF) continue;
             for (int t = r; t; t = (t - ) & r)
                 dp[s | t][d + ] = min(dp[s | t][d + ], dp[s][d] + tmp[t] * d);
         }
     }
     LL ans = LLINF;
     for (int i = ; i <= n; ++i) ans = min(ans, dp[S][i]);
     return ans;
 }

 int main() {

     n = read(), m = read();

     for (int i = ; i <= n; ++i)
         for (int j = ; j <= n; ++j) mp[i][j] = INF;
     for (int i = ; i <= m; ++i) {
         int u = read() - , v = read() - , w = read();
         mp[u][v] = min(mp[u][v], w), mp[v][u] = min(mp[v][u], w);
     }

     LL ans = 1e18;
     for (int i = ; i < n; ++i)
         ans = min(ans, solve(i));
     cout << ans;

     return ;
 }

3、随机化算法