dp练习 2016.2.24

---

　　很经典的一道状压dp(似乎叫做旅行商问题)，用f[i][s]表示在到达点i，已经经过的城市用二进制表示为s，于是方程就很简单了:

f[i][s] = min { f[j][s ^ (1 << j)] + dis[j][i]| s & (1 << j) != 0}

　　然后用记忆化搜索即可，注意方向，因为dis[i][j]可能不等于dis[j][i]。（下面的代码某个处理似乎没有必要）

Code

 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<cstring>
 #include<cstdlib>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<queue>
 #include<vector>
 #include<stack>
 using namespace std;
 typedef bool boolean;
 #define INF 0xfffffff
 #define smin(a, b) a = min(a, b)
 #define smax(a, b) a = max(a, b)
 template<typename T>
 inline void readInteger(T& u){
     char x;
     int aFlag = ;
     while(!isdigit((x = getchar())) && x != '-');
     if(x == '-'){
         x = getchar();
         aFlag = -;
     }
     for(u = x - ''; isdigit((x = getchar())); u = (u << ) + (u << ) + x - '');
     ungetc(x, stdin);
     u *= aFlag;
 }

 int n;
 int dis[][];
 int f[][( << )];
 boolean vis[][( << )];

 inline void init() {
     readInteger(n);
     for(int i = ; i <= n; i++)
         for(int j = ; j <= n; j++)
             readInteger(dis[i][j]);
     for(int i = ; i <= n; i++)
         dis[i][] = dis[i][], dis[][i] = dis[][i];
 }

 int dfs(int local, int status) {
     if(vis[local][status])    return f[local][status];
     vis[local][status] = true;
     for(int i = ; i <= n; i++) {
         if(status & ( << i)) {
             int ret = dfs(i, status ^ ( << i));
             smin(f[local][status], f[i][status ^ ( << i)] + dis[i][local]);
         }
     }
     return f[local][status];
 }

 inline void solve() {
     memset(vis, false, sizeof(vis));
     memset(f, 0x7f, sizeof(f));
     vis[][] = true;
     f[][] = ;
     int res = dfs(, ( << (n + )) - );
     printf("%d", res);
 }

 int main() {
     freopen("salesman.in", "r", stdin);
     freopen("salesman.out", "w", stdout);
     init();
     solve();
     return ;
 }

---

---

　　因为关灯不耗时间，所以从一个地方走到另一个地方，从贪心的角度来讲，肯定要把沿路的灯都关掉，因此得到原问题转化成了区间dp。当然还要考虑是从做走到右还是从右走到左，当然可以直接用f[i][j]表示，但是为了防止各种手抽手贱导致半天调不出来，还是加了一维[0/1]，表示在从右走到左(0)还是从左走到右。于是方程很容易就出来了，详细的看代码，这里就简单地写了，从f[i][j]转移到f[i - 1][j]或者f[i][j + 1]，然后加上路程乘以未被关掉的所有灯的功率。

　　至于这个功率可以用前缀和先预处理出，接着用总功率减去这一段的功率就行了。

　　由于开始以为灯的位置不是有序的，特意排了道序，可以无视。

Code

 #include<iostream>
 #include<cstdio>
 #include<cctype>
 #include<cstring>
 #include<cstdlib>
 #include<fstream>
 #include<sstream>
 #include<algorithm>
 #include<map>
 #include<set>
 #include<queue>
 #include<vector>
 #include<stack>
 using namespace std;
 typedef bool boolean;
 #ifdef    WIN32
 #define AUTO "%I64d"
 #else
 #define AUTO "%lld"
 #endif
 #define INF 0xfffffff
 #define smin(a, b) a = min(a, b)
 #define smax(a, b) a = max(a, b)
 template<typename T>
 inline void readInteger(T& u){
     char x;
     int aFlag = ;
     while(!isdigit((x = getchar())) && x != '-');
     if(x == '-'){
         x = getchar();
         aFlag = -;
     }
     for(u = x - ''; isdigit((x = getchar())); u = (u << ) + (u << ) + x - '');
     ungetc(x, stdin);
     u *= aFlag;
 }

 typedef class tower {
     public:
         int pos;
         int w;
         int index;
         tower(const int pos = , const int w = , const int index = ):pos(pos), w(w), index(index) {        }

         boolean operator < (tower a) const {
             return pos < a.pos;
         }
 }tower;

 int n, c, rc;
 long long f[][][];
 tower tows[];
 long long sumw[];

 inline void init() {
     readInteger(n);
     readInteger(c);
     for(int i = ; i <= n; i++) {
         readInteger(tows[i].pos);
         readInteger(tows[i].w);
         tows[i].index = i;
     }
     sort(tows + , tows + n + );
     sumw[] = ;
     for(int i = ; i <= n; i++) {
         sumw[i] = sumw[i - ] + tows[i].w;
         if(tows[i].index == c)    rc = i;
     }
 }

 inline void solve() {
     memset(f, 0x37, sizeof(f));
     f[][rc][rc] = f[][rc][rc] = ;
     if(rc > )
         f[][rc - ][rc] = (tows[rc].pos - tows[rc - ].pos) * (sumw[n] - tows[rc].w);
     if(rc < n)
         f[][rc][rc + ] = (tows[rc + ].pos - tows[rc].pos) * (sumw[n] - tows[rc].w);
     for(int l = ; l < n; l++) {
         for(int i = ; i + l <= n; i++) {
             int j = i + l;
             if(i > ) {
                 smin(f[][i - ][j], f[][i][j] + (sumw[n] - (sumw[j] - sumw[i - ])) * (tows[i].pos - tows[i - ].pos));
                 smin(f[][i - ][j], f[][i][j] + (sumw[n] - (sumw[j] - sumw[i - ])) * (tows[j].pos - tows[i - ].pos));
             }
             if(j < n) {
                 smin(f[][i][j + ], f[][i][j] + (sumw[n] - (sumw[j] - sumw[i - ])) * (tows[j + ].pos - tows[j].pos));
                 smin(f[][i][j + ], f[][i][j] + (sumw[n] - (sumw[j] - sumw[i - ])) * (tows[j + ].pos - tows[i].pos));
             }
         }
     }
     long long res = smin(f[][][n], f[][][n]);
     printf(AUTO, res);
 }

 int main() {
     freopen("power.in", "r", stdin);
     freopen("power.out", "w", stdout);
     init();
     solve();
     return ;
 }

（题外话）