暑假训练-训练8 区间DP

最新推荐文章于 2022-08-13 10:58:50 发布
最新推荐文章于 2022-08-13 10:58:50 发布
阅读量352 收藏
点赞数
分类专栏： acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Katapeltes/article/details/52097985
版权

A - 石子归并
Time Limit:1000MS Memory Limit:131072KB 64bit IO Format:%lld & %llu
Submit

Status
Description
现在有n堆石子，第i堆有ai个石子。现在要把这些石子合并成一堆，每次只能合并相邻两个，每次合并的代价是两堆石子的总石子数。求合并所有石子的最小代价。

Input
第一行包含一个整数T（T<=50），表示数据组数。
每组数据第一行包含一个整数n（2<=n<=100），表示石子的堆数。
第二行包含n个正整数ai（ai<=100），表示每堆石子的石子数。

Output
每组数据仅一行，表示最小合并代价。

Sample Input
2
4
1 2 3 4
5
3 5 2 1 4
Sample Output
19
33

A:
F[i][j]表示在[i,j]上的最优解

#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
const int MAX=105;
const int INF=99999999;
int A[MAX],sum[MAX],F[MAX][MAX];
int main()
{
    int T,n;
    scanf("%d",&T);
    while(T--)
    {
        memset(sum,0,sizeof(sum));
        memset(F,0,sizeof(F));
        scanf("%d",&n);
        for (int i=1;i<=n;i++)
        {
            scanf("%d",&A[i]);
            sum[i]=sum[i-1]+A[i];
        }
        for (int l=2;l<=n;l++)
        {
            for (int i=1;i<=n-l+1;i++)
            {
                int j=i+l-1;
                F[i][j]=INF;
                for (int k=i;k<j;k++)
                {
                    F[i][j]=min(F[i][j],F[i][k]+F[k+1][j]+sum[j]-sum[i-1]);
                    //cout<<"F["<<i<<"]["<<j<<"]="<<F[i][j]<<endl;
                }
            }
        }
        printf("%d\n",F[1][n]);
    }
    return 0;
}

B - Brackets
Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu
Submit

Status
Description
We give the following inductive definition of a “regular brackets” sequence:

the empty sequence is a regular brackets sequence,
if s is a regular brackets sequence, then (s) and [s] are regular brackets sequences, and
if a and b are regular brackets sequences, then ab is a regular brackets sequence.
no other sequence is a regular brackets sequence
For instance, all of the following character sequences are regular brackets sequences:

(), [], (()), ()[], ()[()]

while the following character sequences are not:

(, ], )(, ([)], ([(]

Given a brackets sequence of characters a1a2 … an, your goal is to find the length of the longest regular brackets sequence that is a subsequence of s. That is, you wish to find the largest m such that for indices i1, i2, …, im where 1 ≤ i1 < i2 < … < im ≤ n, ai1ai2 … aim is a regular brackets sequence.

Given the initial sequence ([([]])], the longest regular brackets subsequence is [([])].

Input
The input test file will contain multiple test cases. Each input test case consists of a single line containing only the characters (, ), [, and ]; each input test will have length between 1 and 100, inclusive. The end-of-file is marked by a line containing the word “end” and should not be processed.

Output
For each input case, the program should print the length of the longest possible regular brackets subsequence on a single line.

Sample Input
((()))
()()()
([]])
)[)(
([][][)
end
Sample Output
6
6
4
0
6




B:
F[i][j]表示[i,j]范围内的合法数

#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
const int MAX=105;
const int INF=99999999;
int F[MAX][MAX];
int main()
{
    string s;
    while(cin>>s&&s[0]!='e')
    {
        int len=s.length();
        s.insert(0,1,' ');
        memset(F,0,sizeof(F));
        for (int l=2;l<=len;l++)
        {
            for (int i=1;i<=len-l+1;i++)
            {
                int j=i+l-1;
                if ((s[i]=='('&&s[j]==')')||(s[i]=='['&&s[j]==']'))
                    F[i][j]=F[i+1][j-1]+2;
                for (int k=i;k<j;k++)
                {
                    F[i][j]=max(F[i][j],F[i][k]+F[k+1][j]);
                }
            }
        }
        cout<<F[1][len]<<endl;
    }
    return 0;
}

C - Halloween Costumes
Time Limit:2000MS Memory Limit:32768KB 64bit IO Format:%lld & %llu
Submit

Status
Description
Gappu has a very busy weekend ahead of him. Because, next weekend is Halloween, and he is planning to attend as many parties as he can. Since it’s Halloween, these parties are all costume parties, Gappu always selects his costumes in such a way that it blends with his friends, that is, when he is attending the party, arranged by his comic-book-fan friends, he will go with the costume of Superman, but when the party is arranged contest-buddies, he would go with the costume of ‘Chinese Postman’.

Since he is going to attend a number of parties on the Halloween night, and wear costumes accordingly, he will be changing his costumes a number of times. So, to make things a little easier, he may put on costumes one over another (that is he may wear the uniform for the postman, over the superman costume). Before each party he can take off some of the costumes, or wear a new one. That is, if he is wearing the Postman uniform over the Superman costume, and wants to go to a party in Superman costume, he can take off the Postman uniform, or he can wear a new Superman uniform. But, keep in mind that, Gappu doesn’t like to wear dresses without cleaning them first, so, after taking off the Postman uniform, he cannot use that again in the Halloween night, if he needs the Postman costume again, he will have to use a new one. He can take off any number of costumes, and if he takes off k of the costumes, that will be the last k ones (e.g. if he wears costume A before costume B, to take off A, first he has to remove B).

Given the parties and the costumes, find the minimum number of costumes Gappu will need in the Halloween night.

Input
Input starts with an integer T (≤ 200), denoting the number of test cases.

Each case starts with a line containing an integer N (1 ≤ N ≤ 100) denoting the number of parties. Next line contains N integers, where the ith integer ci (1 ≤ ci ≤ 100) denotes the costume he will be wearing in party i. He will attend party 1 first, then party 2, and so on.

Output
For each case, print the case number and the minimum number of required costumes.

Sample Input
2
4
1 2 1 2
7
1 2 1 1 3 2 1
Sample Output
Case 1: 3
Case 2: 4


C: F[i][j]表示在区间[i,j]内需要的最小衣服数量.首先初始化为j-i+1(最大值),F[i][j]=F[i+1][j]+1;
   F[i][j]=min(F[i][j],F[i+1][k-1]+F[k][j]) 找到与第i个相同的(k),分解成两个子问题.

#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
const int MAX=105;
const int INF=99999999;
int T,N,A[MAX],F[MAX][MAX];
int main()
{
    cin>>T;
    for (int a=1;a<=T;a++)
    {
        memset(F,0,sizeof(F));
        cin>>N;
        for (int i=1;i<=N;i++)
        {
            cin>>A[i];
        }
        for (int i=1;i<=N;i++)
            for (int j=i;j<=N;j++)
                F[i][j]=j-i+1;
        for (int l=2;l<=N;l++)
        {
            for (int i=N-l+1;i>=1;i--)
            {
                int j=i+l-1;
                F[i][j]=F[i+1][j]+1;
                for (int k=i+1;k<=j;k++)
                {
                    if (A[k]==A[i])
                    {
                        F[i][j]=min(F[i][j],F[i+1][k-1]+F[k][j]);
                    }
                }
            }
        }
        cout<<"Case "<<a<<": "<<F[1][N]<<endl;
    }
    return 0;
}

D - You Are the One
Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d & %I64u
Submit

Status
Description
　　The TV shows such as You Are the One has been very popular. In order to meet the need of boys who are still single, TJUT hold the show itself. The show is hold in the Small hall, so it attract a lot of boys and girls. Now there are n boys enrolling in. At the beginning, the n boys stand in a row and go to the stage one by one. However, the director suddenly knows that very boy has a value of diaosi D, if the boy is k-th one go to the stage, the unhappiness of him will be (k-1)*D, because he has to wait for (k-1) people. Luckily, there is a dark room in the Small hall, so the director can put the boy into the dark room temporarily and let the boys behind his go to stage before him. For the dark room is very narrow, the boy who first get into dark room has to leave last. The director wants to change the order of boys by the dark room, so the summary of unhappiness will be least. Can you help him?
Input
　　The first line contains a single integer T, the number of test cases. For each case, the first line is n (0 < n <= 100)
　　The next n line are n integer D1-Dn means the value of diaosi of boys (0 <= Di <= 100)
Output
　　For each test case, output the least summary of unhappiness .
Sample Input
2
　　
5
1
2
3
4
5

5
5
4
3
2
2
Sample Output
Case #1: 20
Case #2: 24



D: F[i][j]表示在区间[i,j]中的最小值 小黑屋是一个栈 假设i第k个上场 则分解为F[i+1][i+k-1]和F[i+k][j]

#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
const int MAX=105;
const int INF=99999999;
int T,N,A[MAX],F[MAX][MAX],SUM[MAX];
int main()
{
    cin>>T;
    for (int a=1;a<=T;a++)
    {
        memset(F,0,sizeof(F));
        memset(SUM,0,sizeof(SUM));
        cin>>N;
        for (int i=1;i<=N;i++)
        {
            cin>>A[i];
            SUM[i]=SUM[i-1]+A[i];
        }
        for (int l=2;l<=N;l++)
        {
            for (int i=1;i<=N-l+1;i++)
            {
                int j=i+l-1;
                F[i][j]=INF;
                for (int k=1;k<=j-i+1;k++)
                {
                    F[i][j]=min(F[i][j],F[i+1][i+k-1]+(k-1)*A[i]+F[i+k][j]+k*(SUM[j]-SUM[i+k-1]));
                }
            }
        }
        cout<<"Case #"<<a<<": "<<F[1][N]<<endl;
    }
    return 0;
}

E - Multiplication Puzzle
Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu
Submit

Status
Description
The multiplication puzzle is played with a row of cards, each containing a single positive integer. During the move player takes one card out of the row and scores the number of points equal to the product of the number on the card taken and the numbers on the cards on the left and on the right of it. It is not allowed to take out the first and the last card in the row. After the final move, only two cards are left in the row.

The goal is to take cards in such order as to minimize the total number of scored points.

For example, if cards in the row contain numbers 10 1 50 20 5, player might take a card with 1, then 20 and 50, scoring
10*1*50 + 50*20*5 + 10*50*5 = 500+5000+2500 = 8000

If he would take the cards in the opposite order, i.e. 50, then 20, then 1, the score would be
1*50*20 + 1*20*5 + 10*1*5 = 1000+100+50 = 1150.
Input
The first line of the input contains the number of cards N (3 <= N <= 100). The second line contains N integers in the range from 1 to 100, separated by spaces.
Output
Output must contain a single integer - the minimal score.
Sample Input
6
10 1 50 50 20 5
Sample Output
3650


E:
F[i][j]表示在[i,j)区间的最优解

#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
const int MAX=105;
const int INF=99999999;
int A[MAX],F[MAX][MAX];
bool used[MAX];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        memset(F,0,sizeof(F));
        for (int i=0;i<MAX;i++)
            used[i]=false;
        for (int i=1;i<=n;i++)
            scanf("%d",&A[i]);
        for (int l=2;l<=n-1;l++)
        {
            for (int i=2;i<=n-l+1;i++)
            {
                int j=i+l-1;
                F[i][j]=INF;
                for (int k=i;k<j;k++)
                {
                    F[i][j]=min(F[i][j],F[i][k]+F[k+1][j]+A[i-1]*A[k]*A[j]);
                    //cout<<"F["<<i<<"]["<<j<<"]="<<F[i][j]<<endl;
                }
            }
        }
        cout<<F[2][n]<<endl;
    }
    return 0;
}

F - Running
Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu
Submit

Status
Description
The cows are trying to become better athletes, so Bessie is running on a track for exactly N (1 ≤ N ≤ 10,000) minutes. During each minute, she can choose to either run or rest for the whole minute.

The ultimate distance Bessie runs, though, depends on her ‘exhaustion factor’, which starts at 0. When she chooses to run in minute i, she will run exactly a distance of Di (1 ≤ Di ≤ 1,000) and her exhaustion factor will increase by 1 – but must never be allowed to exceed M (1 ≤ M ≤ 500). If she chooses to rest, her exhaustion factor will decrease by 1 for each minute she rests. She cannot commence running again until her exhaustion factor reaches 0. At that point, she can choose to run or rest.

At the end of the N minute workout, Bessie’s exaustion factor must be exactly 0, or she will not have enough energy left for the rest of the day.

Find the maximal distance Bessie can run.

Input
* Line 1: Two space-separated integers: N and M
* Lines 2..N+1: Line i+1 contains the single integer: Di

Output
* Line 1: A single integer representing the largest distance Bessie can run while satisfying the conditions.
　

Sample Input
5 2
5
3
4
2
10
Sample Output
9


F:



#include<stdio.h>
#include<string>
#include<cstring>
#include<queue>
#include<algorithm>
#include<functional>
#include<vector>
#include<iomanip>
#include<math.h>
#include<iostream>
#include<sstream>
#include<set>
using namespace std;
const int MAX=10005;
const int INF=99999999;
int A[MAX],F[MAX][505]; //F[i][j] 第i分钟疲劳值为j时的最大距离
int N,M;
int main()
{
    while(scanf("%d%d",&N,&M)!=EOF)
    {
        memset(F,0,sizeof(F));
        for (int i=1;i<=N;i++)
            scanf("%d",&A[i]);
        for (int i=1;i<=N;i++)
        {
            for (int j=1;j<=M&&j<=i;j++)
                F[i][j]=F[i-1][j-1]+A[i];
            F[i][0]=F[i-1][0];
            for (int j=1;j<=M&&i-j>=0;j++)
                F[i][0]=max(F[i-j][j],F[i][0]);
        }
        cout<<F[N][0]<<endl;
    }
    return 0;
}
Katapeltes
关注
专栏目录
『杭电1705』Count the grid
漠宸离若的博客
09-27 208
Problem Description A lattice point is an ordered pair (x, y) where x and y are both integers. Given the coordinates of the vertices of a triangle (which happen to be lattice points), you are to count the number of lattice points which lie completely ins
League of Legends -- 2021牛客暑期多校训练营2
weixin_45509601的博客
07-20 449
题意:把给出的n条线段分成k组，使得每组都保证线段有交，或者是一条线。求最后所有k个组交的长度的和。 想做这道题首先要搞清楚几个点： 1，怎么处理复杂关系的区间。 2，知道是dp之后，怎么推转移方程。 3，如何进行优化。 这里面最难想的可能是第一个点了。因为在做这道题前我已经假定这道题是dp题，于是我首先试着写一下转移方程 for(int i = 1;i <= 0;i++) //n person for(int j = 1;j <= k j++) //k group
动态规划区间dp和状压dp习题
zhL816的博客
05-12 537
文章目录问题1问题描述样例输入样例输出解题思路代码问题2问题描述样例输入样例输出解题思路代码问题3问题描述样例输入样例输出解题思路代码 问题1 问题描述 东东每个学期都会去寝室接受扫楼的任务，并清点每个寝室的人数。 每个寝室里面有ai个人(1<=i<=n)。从第i到第j个宿舍一共有sum(i,j)=a[i]+…+a[j]个人 这让宿管阿姨非常开心，并且让东东扫楼m次，每一次数第i到第j个宿舍sum(i,j) 问题是要找到sum(i1, j1) + … + sum(im,jm)的最大值。且ix &
POJ2954 Triangle
dezhen7015的博客
02-28 93
Time Limit:1000MS Memory Limit:65536K Total Submissions:5869 Accepted:2524 Description Alattice pointis an ordered pair (x,y) wherexandyare both intege...
C - Brackets（区间dp）
默的博客
08-03 661
Description Input The input test file will contain multiple test cases. Each input test case consists of a single line containing only the characters (, ), [, and ]; each input test will have length ...
POJ 3070
ericxieforever的专栏
04-07 1291
 Fibonacci Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 1253   A
2020暑期牛客多校训练营第九场（C）Groundhog and Gaming Time(数学期望，线段树，逆元)
s260127ljy的博客
08-09 272
Groundhog and Gaming Time 原题请看这里 题目描述; 在PKUWC2019day2PKUWC2019day2PKUWC2019day2晚上，n{n}n个同学包括Soetdit，TX1145967673，ZPAYAUR，GroundhogSoetdit，TX1145967673，ZPAYAUR，GroundhogSoetdit，TX1145967673，ZPAYAUR，Groundhog做出了一个了不起的决定：他们准备参加一个车队，他们将分担一夜直到黎明。 那天晚上，他们一个接一个地上
“蔚来杯“2022牛客暑期多校训练营7 JK题解
Shanhj的博客
08-13 1076
记录了J题的题解
2021牛客暑期多校训练营2
yaoyuebaba的博客
07-21 127
K 题目大意：给出N和M，有M个输入，每次输入两个数p，x，表示有一个数组b，从a[1]开始到a[p]，这p个数的最长上升子序列为x，即b[p] = x。输出符合b数组的a数组，不存在就输出01。 解题思路：显然对于每一个 b[i]，必须满足 b[i]≤i，那么对于未给出数值的 b[i]，可以考虑先给它们填充上数值，不妨令 b[i] = b[i - 1] + 1，这样构造能够满足b[i]≤i的条件，随后只需要从后往前构造即可。填充完b数组，我们借助栈来从后往前构造a数组即可。 #include <bi
2020.7.21 T4WTF交换（jz暑假训练day6）
jay_zai的博客
07-22 146
sum = 0 for i = 1 to N index = min{ ID[i], ID[i+1] } sum = sum + A[index] 将数组A往右循环移动R位 将数组A内所有的数取相反数 for i = 1 to N index = max{ ID[i], ID[i+1] } index = index + 1 sum = sum + A[index] 将数组A往右循环移动R位
逆序输出 题解
young_1217的博客
10-26 1659
题目描述 依次输入n个数，再依次将其逆序输出。 输入 第一行一个数n（n<100） 第二行n个int范围以内的数，之间以空格隔开 输出 一行n个数，逆序输出输入的数 样例 样例输入1 5 2 3 4 1 5 样例输出1 5 1 4 3 2 AC代码 #include<bits/stdc++.h> using namespace std; int a[102]; int n; int main(){ cin >> n; for (in
2021/11/25 C++均值
hu138530的博客
11-25 971
描述 给出一组样本数据，计算其均值。 输入 输入有两行，第一行包含一个整数n（n小于100），代表样本容量；第二行包含n个绝对值不超过1000的浮点数，代表各个样本数据。 输出 输出一行，包含一个浮点数，表示均值，精确到小数点后4位。 样例输入 2 1.0 3.0 样例输出 2.0000 法一：利用循环结构 #include<iostream> using namespace std; int main() { int n; double m,average,su
BUCT c语言程序设计基础第三篇10~20道题（上）
m0_62498611的博客
07-22 1250
算法学习
week12作业
ych7777777的博客
05-18 198
C - 必做题 - 3 东东每个学期都会去寝室接受扫楼的任务，并清点每个寝室的人数。 每个寝室里面有ai个人(1<=i<=n)。从第i到第j个宿舍一共有sum(i,j)=a[i]+…+a[j]个人 这让宿管阿姨非常开心，并且让东东扫楼m次，每一次数第i到第j个宿舍sum(i,j) 问题是要找到sum(i1, j1) + … + sum(im,jm)的最大值。且ix <= iy <=jx和ix <= jy <=jx的情况是不被允许的。也就是说m段都不能相交。 注：1 ≤ i
POJ 3074 Sudoku
忘梦心的博客
11-15 700
Sudoku Time Limit: 1000MS Memory Limit: 65536K Description In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3 subgrids. For example, . 2 7 3 8 . . 1 . . 1 . . . 6 7 3 ...
POJ - 2955（2020.4.19训练C题）
rainbowower的博客
04-23 238
Problem We give the following inductive definition of a “regular brackets” sequence: the empty sequence is a regular brackets sequence, if s is a regular brackets sequence, then (s) and [s] ar...
区间DP小结(附经典例题)
热门推荐
Dust_heart的博客
08-13 2万+
——这篇文章主要想总结下区间DP的经典题目，同时给自己复习巩固这方面知识点。 区间DP 一、定义 区间DP，顾名思义是在区间上DP，它的主要思想就是先在小区间进行DP得到最优解，然后再利用小区间的最优解合并求大区间的最优解。 二、实现思路 下面给出区间DP最简单形式的伪代码(具体要根据题目修改) //mst(dp,0) 初始化DP数组 for......
（说了好多话好多好多）POJ - 3070
qq_43813697的博客
05-27 384
转-知乎王希：https://www.zhihu.com/question/28062458 Description In the Fibonacci integer sequence,F0= 0,F1= 1, andFn=Fn− 1+Fn− 2forn≥ 2. For example, the first ten terms of the Fibonacci s...
数组元素的删除 【vector】
banshen0201的博客
03-23 1745
7-5 数组元素的删除（5 分） 完成数组元素的移动功能：假设数组有n个元素，输入一个数x，把数组的第x个位置的元素删除了，后面的元素依次前进一个位置。 重复若干次这样的删除，得到最后的结果。 输入格式: 第一行包括一个整数n（1<=n<=100），表示数组元素的个数。 第二行输入n个数组元素，均为整数，用空格隔开。 第三行输入一个数k...
西门子PROFIBUS-DP技术培训教程
"西门子PROFIBUS-DP教材，深入讲解了PROFIBUS-DP技术在工业自动化中的应用，包括设备类型、系统结构和实际案例" PROFIBUS-DP，全称为Process Field Bus - Distributed Peripheral，是国际开放的现场总线标准之一，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值