HDU5900-QSC and Master-区间DP+区间覆盖DP

地址 http://acm.hdu.edu.cn/showproblem.php?pid=5900

2016ICPC沈阳赛区网络赛

题意：一个队列，每个点有key[i]和value[i]，位置相邻且key不互质的两个点可以被取走，取走后，剩下点自动连接起来。

　　　　问取走的value和最大

题解：1.对于所有的区间，用区间DP求出能否 整个 区间取走

　　　　　　枚举区间长度

　　　　　　对于[s,e] 的区间，要么由两个比这短的区间拼凑而成，要么s和e可以不互质，且[s+1,e-1]可以取走，特判长度为2的时候。

　　　2.对于所有能取走的区间，有区间覆盖（覆盖一次）问题

　　　3.DP解决问题2

　　　　　　对于所有区间按照终点排序

　　　　　　对于不是终点的i，dp[i] = dp[i-1]

　　　　　　对于是终点的i，dp[i] = max( dp[ i - 1 ] , { E.Svalue | E.end == i } )

　　　　　　坐标轴上的单向最短（长）路问题和这个类似

沈阳站赛前复习，希望自己沈阳加油。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
long long a[333];
long long b[333];
long long sum[333];
long long dp[333];
struct Edge
{
    int s,e;
    long long val;
}E[93333];
int ife[333][333];
long long gcd(long long aa, long long bb)
{
        return bb == 0 ? aa : gcd(bb,aa % bb);
}
bool com(Edge A,Edge B)
{
        return A.e < B.e;
}
void addedge(int s, int e)
{
    ife[s][e] = 1;
    E[cnt].s = s;
    E[cnt].e = e;
    E[cnt].val = sum[e] - sum[s-1];
    cnt++;
}
int main()
{
     int T;
     //freopen("in.txt","r",stdin);
     cin >> T;
     while (T--)
     {
        memset(E,0,sizeof(E));
        memset(ife,0,sizeof(ife));
        memset(dp,0,sizeof(dp));
        sum[0] = 0;
        int N;
        cin >> N;
        for (int i = 1; i<= N; i++)
        {
            scanf("%lld",&a[i]);
        }
        for (int i = 1; i<= N; i++)
        {
            scanf("%lld",&b[i]);
            sum[i] = sum[i-1] + b[i];
        }
        int cnt = 1;
        //区间DP建边
        //如果s，e之间 能通过某种方式全部取出，那么s，e区间建边
        for (int i = 1; i<=N; i+=2)
        {
            for (int s = 1; s+i<=N; s++)
            {
                int e = s+i;
                if (ife[s][e] == 1) continue;
                if (gcd(a[s],a[e]) != 1LL && (i == 1 || ife[s+1][e-1] == 1))
                {
                    addedge(s,e);
                    continue;
                }
                for (int l = s + 1 ;l <= e-2; l += 2 )
                {
                    if (ife[s][l] == 1 && ife[l+1][e] == 1)
                    {
                        addedge(s,e);
                        break;
                    }
                }
            }
        }
        //每个点只能被选一次，转换为区间一次性覆盖，所有的区间都已经经过区间dp求出
        //区间一次性覆盖 可以用DP求
        sort(E+1,E+cnt,com);
        for (int i = 1; i<cnt;)
        {
            int te = E[i].e;
            while (E[i].e == te)
            {
                dp[te] = max(dp[te],dp[E[i].s-1] + E[i].val);
                i++;
            }
            for (int j = te+1 ; j <= E[i].e ; j++)
                dp[j] = dp[j-1];
        }
        //此处不要输出dp[N],因为dp的范围就是最后一条边的终点
        cout << dp[E[cnt-1].e] <<endl;
     }
}