2017暑期集训Day 14 区间dp+二分图匹配

最新推荐文章于 2020-12-13 19:01:53 发布
最新推荐文章于 2020-12-13 19:01:53 发布
阅读量333 收藏 1
点赞数
分类专栏： SDU_ACM_Practice DP 文章标签： dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yancy_/article/details/76098853
版权

题目链接

A Multiplication Puzzle

[Solution]

区间dp水题

[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 1000 + 5;
#define inf 0x3f3f3f3f
vector<int > s[N];
int f[N][N];
int n, a[N];
int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
          f[i][j] = inf;
    for(int i = 1; i <= n; i++)
    {
        f[i][i] = 0;
        f[i][i + 1] = 0;
    }
    for(int p = 2; p < n; p++)
      for(int i = 1; p + i <= n; i++)
      {
          int j = i + p;
          for(int k = i + 1; k < j; k++)
            f[i][j] = min(f[i][j], f[i][k] + f[k][j] + a[i] * a[j] * a[k]);
      }
    printf("%d", f[1][n]);
    return 0;
}

B - Coloring Brackets

[Problem]

给定一个合法的括号序列，现在我们给括号染色，可以染成红色和蓝色，询问最终方案数。
[Solution]

使用f[i][j][l][r]代表（i，j）这个区间左端l状态，右端j状态的方案数，这样分i、j匹配和不匹配来分类讨论，注意为了简化编码复杂度，我们可以可以将不合法的状态方案数标记为0，这样累加的时候判断相对容易

[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
typedef long long ll;
const int N = 700 + 50;
const int mo = 1e9 + 7;
#define inf 0x3f3f3f3f
string ss;
int n, m, k, Case = 0, l[N];
ll f[N][N][3][3];
int main()
{
  //  freopen("b.in", "r", stdin);
    cin>>ss;
    n = ss.length();
    stack<int> s;
    for(int i = 1; i <= n; i++)
        if (ss[i - 1] == '(')
            s.push(i);
        else
        {
            int x = s.top();
            l[x] = i;
            s.pop();
        }
    for(int i = 1; i < n; i++)
        if (ss[i - 1] == '(' && ss[i] == ')')
    {
        f[i][i + 1][0][1] = 1;
        f[i][i + 1][1][0] = 1;
        f[i][i + 1][0][2] = 1;
        f[i][i + 1][2][0] = 1;
    }
    for(int p = 3; p < n; p++)
        if (p % 2 == 1)
          for(int i = 1; i + p <= n; i++)
    {
        int j = i + p;
        if (l[i] == j)
        {
            for(int ll = 0; ll < 3; ll++)
                for(int rr = 0; rr < 3; rr++)
            {
                if (rr != 1)
                    f[i][j][0][1] = (f[i][j][0][1] + f[i + 1][j - 1][ll][rr]) % mo;
                if (ll != 1)
                    f[i][j][1][0] = (f[i][j][1][0] + f[i + 1][j - 1][ll][rr]) % mo;
                if (ll != 2)
                    f[i][j][2][0] = (f[i][j][2][0] + f[i + 1][j - 1][ll][rr]) % mo;
                if (rr != 2)
                    f[i][j][0][2] = (f[i][j][0][2] + f[i + 1][j - 1][ll][rr]) % mo;
            }
        }
        else
        {
            int x = l[i];
      //      printf("%d %d %d %d\n", i, x, x + 1, j);
            for(int l1 = 0; l1 < 3; l1++)
               for(int r1 = 0; r1 < 3; r1++)
                    for(int r2 = 0; r2 < 3; r2++)
                       for(int l2 = 0; l2 < 3; l2++)
                             if (!((l2 == 1 && r1 == 1) || (l2 == 2 && r1 == 2)) )
                             {
                                 f[i][j][l1][r2] = (f[i][j][l1][r2] + f[i][x][l1][r1] * f[x + 1][j][l2][r2]) % mo;
                                // printf("(%d %d %d %d)- %d   %d\n", l1, r1, l2, r2, f[i][x][l1][r1], f[x + 1][j][l2][r2]);
                             }

        }
    }
    ll ans = 0;
    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 3; j++)
          ans = (ans + f[1][n][i][j]) % mo;
    cout<<ans;
    return 0;
}

C - Halloween Costumes

[Solution]

如果从状态上去考虑此道题目的会gg，因为对于每一天，身上穿的衣服有好多种情况，是不能存储的
我们从每天的决策去考虑，可以选择穿一件新衣服，或者脱掉一些衣服，即我们假设现在是第i天，需要用第k天的衣服，这样（k + 1, j-1）这些天就不能用前i天的衣服了，这样我们用f[i][j]代表（i，j）这些天独立的最优解
f[i][j] = f[i][k] + f[k + 1][j - 1]

[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
typedef long long ll;
const int N = 1000 + 50;
const int mo = 1e9 + 7;
#define inf 0x3f3f3f3f
vector<int > s[N];
typedef long long ll;
int n, m, k, f[N][N], a[N], Case = 0;
int main()
{
 //  freopen("b.in", "r", stdin);
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
              f[i][j] = inf;
        for(int i = 1; i < n; i++)
        {
            f[i][i] = 1;
            if (a[i] == a[i + 1])
                f[i][i + 1] = 1;
            else
                f[i][i + 1] = 2;
        }
        f[n][n] = 1;
        for(int p = 2; p < n; p++)
            for(int i = 1; i + p <= n; i++)
        {
            int j = i + p;
            int t = 1;
            if (a[j] == a[j - 1])
                t = 0;
            f[i][j] = min(f[i][j], f[i][j - 1] + t);
            for(int k = i; k + 1 <= j - 1; k++)
              if (a[k] == a[j])
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j - 1]);
        }
        printf("Case %d: %d\n", ++Case, f[1][n]);

    }
    return 0;
}

D - Food Delivery

[Problem]

坐标轴上有n个点，初始值自己位于一个点，你需要经过每个点一次，每个点有个愤怒值，会随着时间的增加而线性增加，询问总愤怒值最小化的方案。

[Solution]
本题很容易想到部分贪心策略，即在初始点的同一侧的两个点x, y, 离初始点较近的点肯定优先的到满足，因此对于满足[l, r]区间后，肯定位于l位置或r位置，因此我们用f[i][j]代表处理区间(i, j)后，位于i位置，g[i][j]则代表位于j位置的最优解，但是[i][j]区间的最小代价的转移需要到现在位置花费的时间，而我们每次取最小代价维护的最小时间是不对的，因为可能此次尽可能地让时间小一些，虽然此次决策的代价稍大一些，但是下一步的决策要优很多

我们从另一个方向上去考虑吧，我们每次转移的时候不能同时保证两个状态最优，因此我们累加答案可以换一个姿势，先前我们通过点的方式来累加答案，但是时间这个变量难以维护，这下我们通过时间的方式，即此次转移，[i][j]区间之外的点都会增加愤怒值，这样转移就不会出现两个最优性方案了

[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 1000 + 5;
#define inf 0x3f3f3f3f
vector<int > s[N];
ll f[N][N], g[N][N];
ll sum[N];
struct node{
   int x, y;
};
node point[N];
int n, v, st, res;
bool cmp(node a, node b)
{
    return a.x < b.x;
}
int main()
{
//    freopen("b.in", "r", stdin);
    while(~scanf("%d%d%d", &n, &v, &st))
    {
        for(int i = 1; i <= n ;i++)
            scanf("%d%d", &point[i].x, &point[i].y);
        n++;
        point[n].x = st;
        point[n].y = 0;
        sort(point + 1, point + n + 1, cmp);
        for(int i = 1; i <= n; i++)
            if (point[i].x == st)
        {
            res = i;
            break;
        }
        sum[0] = 0LL;
        for(int i = 1; i <= n; i++)
            sum[i] = sum[i - 1] + point[i].y;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
        {
            f[i][j] = inf;
            g[i][j] = inf;
        }
        f[res][res] = 0;
        g[res][res] = 0;
        for(int i = res; i >= 1; i--)
            for(int j = res; j <= n; j++)
        {
            if (i == j && i == res)
                continue;
            f[i][j] = min(f[i][j], f[i + 1][j] + 1LL * abs(point[i + 1].x - point[i].x) * (sum[n] - sum[j] + sum[i]));
            f[i][j] = min(f[i][j], g[i + 1][j] + 1LL * abs(point[j].x - point[i].x) * (sum[n] - sum[j] + sum[i]));
            g[i][j] = min(g[i][j], g[i][j - 1] + 1LL * abs(point[j].x - point[j - 1].x) * (sum[n] - sum[j - 1] + sum[i - 1]));
            g[i][j] = min(g[i][j], f[i][j - 1] + 1LL * abs(point[j].x - point[i].x) * (sum[n] - sum[j - 1] + sum[i - 1]));
         //   printf("f[%d][%d] = %d\n", i, j, f[i][j]);
         //   printf("g[%d][%d] = %d\n", i, j, g[i][j]);
        }
        cout<<min(f[1][n], g[1][n]) * v<<endl;
    }
    return 0;
}

F - Asteroids

[Problem]

N * N 的网格中有k个路障，每次可以清除一列或一行的路障，询问最小次数(n < 500)

[Solution]

对于二分图，有最大匹配数等于最小点覆盖数，即我们选取选取尽可能少的点，使得每个边都有点覆盖，选取的最小点数即最小点覆盖数。
这样我们要清除掉所有的路障，因此我们把路障类比为边， 那什么类比成点呢，每条边连接的东西便是点，而路障连接的不是点数和列数吗？
因此我们把每一行的编号类比成点，每一行的列类比成二分图的另外一部分的点，这样是一个二分图，把路障类比成边，这样跑一遍匈牙利算法算出最小点覆盖数即可

[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int N = 505;
vector<int > s[N];
int girl[N];
bool used[N];
int n, m, k;
bool found(int x)
{
    for(int i = 0; i < s[x].size(); i++)
    {
        int y =  s[x][i];
        if (used[y])  continue;
        used[y] = true;
        if (girl[y] == 0 || found(girl[y]))
        {
            girl[y] = x;
            return 1;
        }
    }
    return 0;
}
int main()
{
   // freopen("b.in", "r", stdin);
    while(~scanf("%d%d", &n, &k))
    {
        memset(girl, 0, sizeof(girl));
        for(int i = 1; i <= n; i++)
            s[i].clear();
        for(int i = 1; i <= k; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            s[x].push_back(y);
        }
        int ans = 0;
        for(int i = 1; i <= n; i++)
        {
            memset(used, 0, sizeof(used));
            if (found(i))
                ans++;
        }
        printf("%d\n", ans);
    }
    return 0;
}

G - Chessboard

[Problem]
N* M的网格中有一些障碍物，现有1*2格纸若干，判断是否将格纸覆盖住网格，使得每一个网格上只有一层贴纸。

[Solution]
十分经典的二分图匹配，首先，同一个贴纸的两个点行数与列数和的奇偶性肯定相反，这样我们把行列数为奇数的为一类点，行列数为偶数的为一类点，这样把一个点与其四周的点，连边，最后跑一边二分图最大匹配即可
[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<stack>
using namespace std;
typedef long long ll;
const int N = 1000 + 50;
const int mo = 1e9 + 7;
#define inf 0x3f3f3f3f
vector<int > s[N];
typedef long long ll;
int n, m, k, a[N][N], girl[N];
bool used[N];
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
bool found(int x)
{
    for(int i = 0; i < s[x].size(); i++)
    {
        int y =  s[x][i];
        if (used[y])  continue;
        used[y] = true;
        if (girl[y] == 0 || found(girl[y]))
        {
            girl[y] = x;
            return 1;
        }
    }
    return 0;
}
int main()
{
  //  freopen("b.in", "r", stdin);
    int n, m, k;
    scanf("%d%d%d", &n, &m, &k);
    int top1 = 0, top2 = 0;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            if ((i + j) % 2 == 0)
              a[i][j] = ++top1;
            else
              a[i][j] = ++top2;
    if ((n * m - k) % 2 == 1)
    {
        printf("NO");
        return 0;
    }
    for(int i = 1; i <= k; i++)
    {
        int x, y;
        scanf("%d%d", &y, &x);
        a[x][y] = -1;
    }
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
           if (a[i][j] > 0 && (i + j) % 2 == 0)
    {
        int x = a[i][j];
        for(int v = 0; v < 4; v++)
        {
            int xx = i + dx[v];
            int yy = j + dy[v];
            if (xx <= 0 || xx > n || yy <= 0 || yy > m)
              continue;
            if (a[xx][yy] <= 0)
                continue;
            int y = a[xx][yy];
            s[x].push_back(y);
          //  printf("---%d %d\n",x , y);
        }
    }
    int ans = 0;
    for(int i = 1; i <= top1; i++)
    {
            memset(used, 0, sizeof(used));
            if (found(i))
                {
                    ans++;
                    //printf("%d\n", i);
                }
    }
   // printf("%d\n", ans);
    int x = n * m - k;
    printf("%s", x == 2 * ans ? "YES" : "NO");
    return 0;
}

H - Book Club

[Problem]

n个人有n本书，每个人都有自己喜欢的书，判断是否存在一种交换方案，使得每个人获得一本自己喜爱的书。

[Solution]

很明显的二分图最大匹配

[Code]

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int N = 10000 + 5;
vector<int > s[N];
int girl[N];
bool used[N];
int n, m, k;
bool found(int x)
{
    for(int i = 0; i < s[x].size(); i++)
    {
        int y =  s[x][i];
        if (used[y])  continue;
        used[y] = true;
        if (girl[y] == 0 || found(girl[y]))
        {
            girl[y] = x;
            return 1;
        }
    }
    return 0;
}
int main()
{
  //  freopen("b.in", "r", stdin);
    while(~scanf("%d%d", &n, &k))
    {
        memset(girl, 0, sizeof(girl));
        for(int i = 1; i <= n; i++)
            s[i].clear();
        for(int i = 1; i <= k; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            x++;
            y++;
            s[x].push_back(y);
        }
        int ans = 0;
        for(int i = 1; i <= n; i++)
        {
            memset(used, 0, sizeof(used));
            if (found(i))
                {
                    ans++;
                   // printf("%d\n", i);
                }
        }
        if (ans == n)
            printf("YES");
        else
            printf("NO");
    }
    return 0;
}
YuHsin
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PKU_暑期训练,计算几何专题+区间图
02-12
【标题】"PKU_暑期训练,计算几何专题+区间图"所涵盖的知识点主要集中在两个领域：计算几何和区间图。计算几何是计算机科学的一个分支，它涉及到几何形状的算法处理，通常与图形学、计算机图形学以及数值计算等领域...
暑假集训周报WEEK4
最新发布
08-04
"暑假集训周报WEEK4" 在这周的集训周报中，我们将讨论三个具有代表性的算法问题：背包问题、纸牌问题和纪念品分组问题。这些问题都是经典的算法问题，都是NOIP（全国青少年信息学奥林匹克竞赛）中的常见题型。 ...
2017暑期集训Day 14 树形dp
Yancy_的博客
07-29 383
POJ 2486 Apple Tree POJ 3345 Bribing FIPA POJ 2378 Tree Cutting POJ 3107 Godfather POJ 3140 Contestants Division HDU 5326 Work CodeForces 696B Puzzles LightOJ 1382 The Queue
2020暑期集训day2 C 图分层DP计数
qq_16267919的博客
12-13 97
类似∑sumi=∑ai(n−i+1)\sum sum_i=\sum a_i(n-i+1)∑sumi​=∑ai​(n−i+1)的优化 代码
2017 暑假艾教集训 day10 AC自动机+马拉车+后缀数组 +kmp
小菜鸟。。
08-10 422
https://vjudge.net/contest/177933#overview H HDU3068 做法：马拉车模板 #include using namespace std; const int maxn= 110015; char s[maxn]; char str[maxn*2]; int dp[maxn*2]; int mlc() { int n=strlen(s+
2017暑期集训Day 2
weixin_30677617的博客
06-30 57
T1:The Largest Clique Code: 1 #include<cstdio> 2 #include<cstring> 3 #include<algorithm> 4 #include<set> 5 #define MN 1005 6 #define ME 50005 7 #define mst(x,y...
2017暑期集训 Day 3 搜索与并查集
Yancy_的博客
07-14 341
A - 食物链[solution] 并查集新操作！ 维护决策的矛盾信息，每次决策之间的选择是互相矛盾的 每个动物可能为三种情况：A、B、C，i代表第i种动物是A类动物，i+n代表第i种动物是B类，i+2*n是c类，这样 对于d=1时，x、y为同类动物，即如果x是a类，则y也为a类，即unite(x,y),同理，都为b类，unite(x+n,y +n),同理，unite(x+2*n,y+2*n
2017暑期集训Day 11 背包
Yancy_的博客
07-21 483
A - Bottles[Problem]有n个苏打水的瓶子，每瓶中装有一定量苏打水，给你每瓶的体积，现在像把这些苏打水装到尽量少的瓶子中，并且移动尽可能少的苏打水。[Solution]f[i]代表凑齐i体积需要瓶子的最小数量，g[i]代表盛有的苏打水体积，在满足f[i]尽可能小的情况下,g[i]最大[Code]#include<cstdio> #include<iostream> #include<
2017暑期集训Day 9 递推
Yancy_的博客
07-21 300
题目地址A Tiling[Solution]递推的时候保证第n个方案是新方案即可，第n块可以使2*2，也可以是1*2的一块，亦或是1*2横过来的两块，这样F[N] = 2 * F[n - 2] + F[n - 1]Ps: 这道题目需要用到高精度，我是用了java的BigInteger来搞的，BigInteger是在math类下的包，另外java程序提交的时候需要把class的名称改成Main，注意M
区间DP小结(附经典例题)
热门推荐
Dust_heart的博客
08-13 2万+
——这篇文章主要想总结下区间DP的经典题目，同时给自己复习巩固这方面知识点。 区间DP 一、定义 区间DP，顾名思义是在区间上DP，它的主要思想就是先在小区间进行DP得到最优解，然后再利用小区间的最优解合并求大区间的最优解。 二、实现思路 下面给出区间DP最简单形式的伪代码(具体要根据题目修改) //mst(dp,0) 初始化DP数组 for......
暑期集训Day (11，12，13，14) 总结（搜索进阶+DP进阶）
star_moon0309的博客
08-17 212
之前一直没写的搜索总结也留到今天写吧。。。 到目前为止，dp已经 复习了  预习了大部分内容，明天应该是最难的dp中的优化部分了，之前了解还不够深入。 个人理解，dp还是要多做题。有些dp还是很套路的，比如说区间dp和数位dp，基本上有板子可套。当然变化也是有的，这个时候就要具体题目具体分析了。。。 作为一个学习dp的菜鸡，这两题疯狂在补各种dp题，可是刷的dp题还是太少了。dp作为十分重要...
北京大学暑期ACM集训资料
09-25
北京大学暑期ACM集训资料是一份综合性的学习资源，旨在帮助学员深入理解和掌握算法与编程技巧，特别是针对ACM（国际大学生程序设计竞赛）的准备。这份资料涵盖了多个关键领域，包括数据结构、搜索技术、动态规划、...
小学生暑假生活手抄报模板，一共14张精美图片
09-23
【标题】"小学生暑假生活手抄报模板，一共14张精美图片"所涉及的知识点主要集中在创意设计、教育和信息传播领域。手抄报是一种常见的教育活动，它结合了艺术、文字和信息整合能力，旨在提升孩子们的创新思维、审美...
2009ACM多校联合暑期集训（14）解题报告 感谢各校的努力
10-12
这篇解题报告主要聚焦于2009年的一场ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）多校联合暑期集训活动的第14天。在这次集训中，各参赛学校的队伍积极参与，共同提升编程技能，...
BZOJ 刷题总结
Yancy_的博客
01-29 1436
背景 辣鸡的人总要想法自救，便产生了寒假学些新算法、在Bzoj刷些题的想法。一来为明年省赛做准备…压力不小；二来寒假也可以有些事情做。 PS 1.不定时更新做题的思路和吐槽 2.按照hzw刷题顺序训练，具体依照BZOJ题表 3.希望寒假能够至少刷够100道题目吧，在此立个FLAG，希望别被青岛的妖风吹跑 Problem &amp; Solution BZOJ 1003 ...
SDU省赛选拔-ACM ICPC 2010–2011, NEERC, Northern Subregional Contest
Yancy_的博客
04-14 1230
A. Alien Communication Masterclass【题目】给定序列A、B，构造一个等式，使得对于任意的A[i]进制都满足，对于任意的B[i]都 不满足【分析i】同一个式子，不同进制的结果如果不相同，一般是在进位上，首先我们可以想到如果对于A序列的进制都满足呢，可以写成x1 * x2 * x3 *x4 = 0这种，每种进制可以构造一个等于0的式子，对于A[i]，可以构造（10 -
sduacm16级寒假训练 自测
Yancy_的博客
02-16 556
POJ 3579 Median【sol】显然，每个点与其他的点形成的差是有序的，这样相当于有n组升序的序列，询问中位数。二分中位数，然后判断比他小的数的个数，复杂度n* logn*logn#include<cstdio> #include<iostream> #include<cstring> #include<cmath> #include<algorithm> using namespace
Educational Codeforces Round 37 所有题目整理！
Yancy_的博客
02-05 464
A.Water The Garden int ct = a / p; if (a % p != 0) ++ct; 等价于 ct = (a + p - 1) / p; B. Tea Queue solution：按照题意模拟即可 C. Swap Adjacent Elements 题意：给定1-n的一个排列，存在一些i，其中1 思路：首先考虑数字1，假设其位置为pos1，必然

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值