acm-DP整理

一、背包
1.各种01背包
void leastOne_Pack(int id, int num ) {//至少取一个；
    int i, j, c, v ;
    for(i = 1 ; i <= num ; i ++ )
    {
        scanf("%d %d", &c, &v) ;
        for(j = T ; j >= c ; j -- ) 
        {// 下面的顺序不能交换；
            if(f[id][j-c] != -1 ) f[id][j] = getMax(f[id][j], f[id][j-c] + v ) ;
            if(f[id-1][j-c] != -1 ) f[id][j] = getMax(f[id][j], f[id-1][j-c] + v ) ;
        }
    }
}
void mostOne_Pack(int id, int num ) { // 最多取一个；
    int i, j ;
    int c[N], v[N] ;
    for(i = 1 ; i <= num ; i ++ ) scanf("%d %d", &c[i], &v[i] ) ;
    for(i = 0 ; i <= T ; i ++ ) f[id][i] = f[id-1][i] ;
    for(i = 1 ; i <= num ; i ++ )
    {
        for(j = T ; j >= c[i] ; j --)
            if(j >= c[i] && f[id-1][j-c[i]] != -1 ) f[id][j] = getMax(f[id][j], f[id-1][j-c[i]] + v[i] ) ;
    } 
}
void common_Pack(int id, int num ){ // 一般的01背包；
    int i, j, c, v ;
    for(i = 0 ; i <= T ; i ++ ) f[id][i] = f[id-1][i] ;
    for(i = 1 ; i <= num ; i ++ )
    {
        scanf("%d %d", &c, &v) ;
        for(j = T ; j >= c ; j -- ) 
            if(f[id][j-c] != -1 ) f[id][j] = getMax(f[id][j], f[id][j-c] + v ) ;
    }
}
2.完全背包
void Comlepte_Pack(){
　　for(i = 0 ; i < n ; i ++ )
　　{
　　            scanf("%d %d", &p, &w ) ;
　　            for(j = w ; j <= vol ; j ++ ) 
                  f[j] = f[j] < f[j-w] + p ? f[j] : f[j-w] + p ;
　　}
}
3.依赖背包
struct Goods{
    int c, v ;
} g[61][61] ;
void dependent_Pack(int vol, int gn ){
    int i, j, k, mc, mv, c, v ;
    for(j = 1, f[0] = 0 ; j <= vol ; j ++ ) f[j] = -1 ;
    for(i = 1 ; i <= gn ; i ++ )
    {
        if( !num[i]) continue ;
        mc = g[i][0].c ; mv = g[i][0].v*mc ;
        for(j = 1, h[0] = 0 ; j <= vol-mc ; j++ ) h[j] = -1 ;
        for(k = 1 ; k < num[i] ; k ++ )//10背包，相当于得到0 - vol-mc种物品；
        {
            c = g[i][k].c ; v = g[i][k].v*c ;
            for(j = vol-mc ; j >= c ; j -- )
                if(h[j-c] != -1 ) h[j] = h[j] > h[j-c]+v ? h[j] : h[j-c]+v ;
        }
        for(j = vol ; j >= mc ; j -- )//对于1 - vol-mc种物品，至多选择一种；
        {
            for(k = 0 ; k <= j-mc ; k ++ )
            {
                if(h[k] == -1 ) continue ;
                c = k+mc ; v = h[k]+mv ;
                if(j >= c && f[j-c] != -1 ) f[j] = f[j] > f[j-c]+v ? f[j] : f[j-c]+v ;
            }
        }
    }
}
二、极大化
1.极大化算法一
以障碍点经过的边作为矩形的左边界，一直向右边扫描
struct Point{
    int x, y ;
}p[MAXN] ;
bool comp(Point a, Point b){
    if(a.x == b.x) return a.y < b.y ;
    else return a.x < b.x ;
}
int DP(){// h,d 表示扫描线的上下端点高度
    int i, j, h, d, s ;
    int ans = 0 ;
    for (i = 1; i <= n; i ++) //枚举障碍点
    {
        h = W ; d = 0 ; 
        for(j = i+1 ; j <= n && h > d ; j ++)
        {
            if(p[i].x == p[j].x || p[j].y > h || p[j].y < d) continue ; 
            // 扫描得到的矩形一定要经过i点
            s = (h-d)*(p[j].x-p[i].x) ;
            ans = ans > s ? ans : s ;
            if(p[j].y < h && p[j].y >= p[i].y) h = p[j].y ; 
            //保证向前扫描一定经过i点
            if(p[j].y > d && p[j].y <= p[i].y) d = p[j].y ;
        }
    }
    return ans ;
}
int solve(){
    int i, j, tx, ans = 0 ;
    while(~scanf("%d %d", &L, &W))
    {
        scanf("%d", &n) ; memset(pre, 0, sizeof(pre)) ;
        for(i = 1 ; i <= n ; i ++) 
        {
            scanf("%d %d", &p[i].x, &p[i].y) ; pre[p[i].y]  = 1 ;
        }
        for(tx = 0, i = 1 ; i <= W ; i ++)
        {
            tx ++ ;
            if(pre[i]) 
            {
                ans = ans > tx ? ans : tx ;
                tx = 0 ;
            }
        }
        ans = ans*L ;
        p[++n].x = 0 ; p[n].y = 0 ; p[++n].x = 0 ; p[n].y = W ;
        p[++n].x = L ; p[n].y = 0 ; p[++n].x = L ; p[n].y = W ;
        sort(p+1, p+1+n, comp) ;
        tx = DP() ; printf("%d
", ans > tx ? ans : tx) ;
    }
  }





2.算法二
 a.悬线的定义：上端点是障碍点或者边界的线段 ；
 (1) h[i][j]表示以点(i,j)结束的悬线的最大长度；
 (2) l[i][j]表示悬线(i,j)左移量，r[i][j]表示其右移量；
 (3) ml[i][j]表示点(i,j)左边最近的障碍点位置，没有时为左边界。同理……
 b.dp方程：
 (1) 如果点(i-1,j)为障碍点或边界(i=0)：
     h[i][j] = 1,l[i][j] = L(大矩形长度),r[i][j] = 0；
 (2) 如果点(i-1,j)不为障碍点:
     h[i][j]=h[i-1][j]+1, 
     l[i][j]=max(l[i-1][j],ml[i][j]), 
     r[i][j]=min(r[i-1][j],mr[i][j]).
description ：取最大周长矩形，该矩形要么由一种颜色覆盖，要么由两种颜色交叉覆盖。
int h[3][MAXN][MAXN], l[3][MAXN][MAXN], r[3][MAXN][MAXN] ;
int mr[3][MAXN][MAXN], ml[3][MAXN][MAXN] ; 
//[i][j] 左右边最近的异色点，没有异色点为边界位置
int map[MAXN][MAXN] ;
void getTable(){//初始化数组
    int i, j ;
    for(i = 1 ; i <= n ; i ++)
    {
        map[i][0] = map[i][1] ; map[i][m+1] = map[i][m] ;
        ml[0][i][0] = 0 ; mr[0][i][m+1] = m+1 ;
        for(j = 1 ; j <= m ; j ++)
        {
            ml[1][i][j] = ml[0][i][j] = 
            (map[i][j]==map[i][j-1]) ? ml[0][i][j-1] : j-1 ;
            ml[2][i][j] = 
            (map[i][j]^map[i][j-1]) ? ml[2][i][j-1] : j-1 ;
        }
        for(j = m ; j ; j --)
        {
            mr[1][i][j] = mr[0][i][j] =
            (map[i][j]==map[i][j+1]) ? mr[0][i][j+1] : j+1 ;
            mr[2][i][j] = 
             (map[i][j]^map[i][j+1]) ? mr[2][i][j+1] : j+1 ;
        }
    }
}
int DP(){
    int i, j, k, ans = 0 ;
    for (i = 1 ; i <= n ; i ++)
        for (j = 1 ; j <= m ; j ++)
        {
            for(k = 0 ; k < 3 ; k ++)
            {
                if(k < 2 && (map[i][j] != k)) continue ;
                bool v = map[i][j]^map[i-1][j] ;
                if(i == 1 || ((2-k) && v) || (!(2-k) && !v) ) //特判
                {
                    h[k][i][j] = 1 ;
                    l[k][i][j] = ml[k][i][j] ;
                    r[k][i][j] = mr[k][i][j] ;
                }
                else                {
                    h[k][i][j] = h[k][i-1][j]+1 ;
                    l[k][i][j] = max(l[k][i-1][j], ml[k][i][j]) ;
                    r[k][i][j] = min(r[k][i-1][j], mr[k][i][j]) ;
                }
                ans = max(ans, 2*(r[k][i][j]-l[k][i][j]-1+h[k][i][j])) ;
            }
        }
    return ans ;
}
int solve(){
        getTable() ; printf("Case #%d: %d
", cas ++, DP()) ;
  }
三、分数规划
1.二分法
double DP(double f){
    int i ;
    double ans ;
    for(i = 1 ; i <= n ; i ++) d[i] = 1.0*a[i] - b[i]*f;
    sum[0] = 0.0 ;
    for(i = 1 ; i <= n ; i ++) sum[i] = sum[i-1] + d[i] ;
    ans = sum[k] ; dp[k] = sum[k] ;
    for(i = k+1 ; i <= n ; i ++)
    {
        dp[i] = max(sum[i]-sum[i-k], dp[i-1]+d[i]) ;
        ans = max(ans, dp[i]) ;
    }
    return ans ;
}
double binary(double l, double r){
    double mid ;
    while(r-l > EPS)
    {
        mid = (l+r)/2.0 ;
        if(DP(mid) > EPS) l = mid+EPS ;
        else r = mid ;
    }
    return l ;
}
2.牛顿逼近法
void build(double s){
    int i, j ;
    for(i = 1 ; i <= n ; i ++)
    for(j = 1 ; j <= n ; j ++)
    {
        map[i][j].d = map[i][j].l - s*map[i][j].c ;
    }
}
double solve(){
    int i ;
    double s, ans = 1.0 ;
    do    {
        s = ans ;
        build(s) ;
        ans = kruskal(1) ;
    }while(fabs(ans-s) > EPS) ;
    return 1.0/ans ;
}
四、经典模型
1.LICS平方算法
int dp[MAXN][MAXN] ; // dp[i][j]表示a[1-i]到b[1-j]且以b[j]结尾的LCIS ；
int dp_LCIS(){
    int i, j, max_l , ans = 0 ;
    for(i = 1 ; i <= m ; i ++) dp[0][i] = 0 ;
    for(i = 1 ; i <= n ; i ++)
    {
        max_l = 0 ;
        for(j = 1 ; j <= m ; j ++)
        {
            dp[i][j] = dp[i-1][j] ;
            if(a[i] > b[j]) max_l = max(max_l, dp[i-1][j]) ;
            //因为相当于a[i] > b[k]与b[j] > b[k]等价( >= 是非递减)；
            if(a[i] == b[j]) dp[i][j] = max_l + 1 ;
        }
        ans = max(ans, dp[i][m]) ;
    }
    return ans ;
}
2.最长回文序列
int solve(){ //最长回文子序列
    int i, j, tmp ; 
    memset(dp, 0, sizeof(dp)) ; 
    for(i = 1 ; i <= 3*n ; i ++) dp[i][i] = 1 ; 
    for(i = 3*n-1 ; i ; i --)
    {
        for(j = i+1 ; j <= 3*n ; j ++)
        {
            dp[i][j] = max(dp[i+1][j], dp[i][j-1]) ; 
            tmp = dp[i+1][j-1] + 2*(ar[i] == ar[j]) ; 
            dp[i][j] = max(dp[i][j], tmp) ; 
        }
    }
    int ans = 1 ; 
    for(i = n+1 ; i <= 2*n ; i ++) ans = max(ans, dp[i-n+1][i+n-1]) ;
    return ans ; 
}
3.最短编辑距离
int solve(){//最短编辑距离
    int i, j, tmp, mx = max(ls, lt) ;
    for(i = 0 ; i <= ls ; i ++)
        for(j = 0 ; j <= lt ; j ++) dp[i][j] = mx ;
    for(i = 0 ; i <= mx ; i ++) dp[i][0] = dp[0][i] = i ;
    for(i = 1 ; i <= ls ; i ++ )
    {
        for(j = 1 ; j <= lt ; j ++)
        {
            tmp = min(dp[i-1][j]+1, dp[i][j-1]+1) ;
            if(s[i] == t[j]) dp[i][j] = min(dp[i][j], min(dp[i-1][j-1], tmp )) ;
            else dp[i][j] = min(dp[i][j], min(tmp, dp[i-1][j-1] + 1)) ;
        }
    }
    for(i = 1 ; i <= ls ; i ++) printf("%d ", dp[i][lt]) ; puts("") ;
    return dp[ls][lt] ;
}
4.最长公共子序列个数
bool solve(){//最长公共子序列个数
    int i, j ; bool d = 0 ;
    memset(f[d], 0, sizeof(f[d])) ; memset(g[d], 0, sizeof(g[d])) ;
    for(i = max(n, m) ; i >= 0 ; i --) g[d][i] = 1 ;
    for(i = 1 ; i <= n ; i ++)
    {
        memset(f[!d], 0, sizeof(f[!d])) ; memset(g[!d], 0, sizeof(g[!d])) ;
        g[!d][0] = 1 ;
        for(j = 1 ; j <= m ; j ++)
        {
            if(s[i] == t[j])
            {
                f[!d][j] = f[d][j-1] + 1 ;
                g[!d][j] = g[d][j-1] ;
                if(f[!d][j] == f[d][j])
                   g[!d][j] = (g[!d][j] + g[d][j]) % MOD ;
                if(f[!d][j] == f[!d][j-1]) 
                   g[!d][j] = (g[!d][j] + g[!d][j-1]) % MOD ;
            }
            else            
             {
                f[!d][j] = max(f[d][j], f[!d][j-1]) ;
                if(f[!d][j] == f[d][j])
                   g[!d][j] = (g[!d][j] + g[d][j]) % MOD ;
                if(f[!d][j] == f[!d][j-1]) 
                   g[!d][j] = (g[!d][j] + g[!d][j-1]) % MOD ;
                if(f[!d][j] == f[d][j-1])
                   g[!d][j] = ( g[!d][j] - g[d][j-1] + MOD) % MOD ;
            }
        }
        d = !d ;
    }
    return d ;
}