2017 济南集训DAY1.AF

Posted 心之所向 素履以往

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了2017 济南集训DAY1.AF相关的知识,希望对你有一定的参考价值。

LIST

  1. T1 水题(water)
  2. T2 梦境(dream)
  3. T2 动态规划(dp)

T1 水题(water)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK出了道水题。

这个水题是这样的:有两副牌,每副牌都有n张。

对于第一副牌的每张牌长和宽分别是xi和yi。对于第二副牌的每张牌长和宽分别是aj和bj。第一副牌的第i张牌能覆盖第二副牌的第j张牌当且仅当xi>=aj并且yi>=bj。(注意牌不能翻转)当然一张牌只能去覆盖最多一张牌,而不能覆盖好多张。

LYK想让两副牌的各n张一一对应叠起来。它想知道第二副牌最多有几张能被第一副牌所覆盖。

 

输入格式(water.in)

第一行一个数n。

接下来n行,每行两个数xi,yi。

接下来n行,每行两个数aj,bj。

 

输出格式(water.out)

输出一个数表示答案。

 

输入样例

3

2 3

5 7

6 8

4 1

2 5

3 4

 

输出样例

2

 

数据范围

对于50%的数据n<=10。

对于80%的数据n<=1000。

对于100%的数据1<=n<=100000,1<=xi,yi,aj,bj<=10^9。

 

思路:正解贪心

   用A中的一张牌 去覆盖 他能覆盖的牌中 最大的那个牌 

   把数组按照左端点排序 

   每一个A牌 去覆盖 他能覆盖的牌中 y最大的那个。

   支持 增加和删除操作 

   可以用某种数据结构来维护 (平衡树? 权值线段树?)

   用multiset 即可

 1 #include <set>
 2 #include <cstdio>
 3 #include <cctype>
 4 #include <algorithm>
 5 
 6 const int MAXN=100010;
 7 
 8 int n,m;
 9 
10 struct node {
11     int x,y;
12     
13     friend inline bool operator < (node x,node y) {
14         return x.x < y.x;
15     }
16 };
17 node A[MAXN],B[MAXN];
18 
19 std::multiset<int> s;
20 
21 inline void read(int&x) {
22     int f = 1;register char c = getchar();
23     for(x = 0;!isdigit(c);c == \'-\' && (f = -1),c = getchar());
24     for(;isdigit(c);x = x * 10 + c - 48,c = getchar());
25     x = x * f;
26 }
27 
28 int main(int argc,char**argv) {
29     freopen("water.in","r",stdin);
30     freopen("water.out","w",stdout);
31     
32     read(n);
33     
34     for(int i = 1; i <= n; ++ i) read(A[i].x),read(A[i].y);
35     
36     for(int i = 1; i <= n; ++ i) read(B[i].x),read(B[i].y);
37     
38     std::sort(A + 1,A + 1 + n);
39     std::sort(B + 1,B + 1 + n);
40     
41     int k = 1,ans = 0;
42     for(int i = 1; i <= n; ++ i) {
43         while(A[i].x >= B[k].x && k <= n) {
44             s.insert(B[k].y);
45             ++k;
46         }
47         if(s.empty()) continue;
48         std::multiset<int>::iterator it=s.upper_bound(A[i].y);
49         if(it == s.begin()) continue;
50         --it;++ans;s.erase(it);
51     }
52     
53     printf("%d\\n",ans);
54     return 0;
55 }
代码

 

T2 梦境(dream)

梦境(dream)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK做了一个梦。

这个梦是这样的,LYK是一个财主,有一个仆人在为LYK打工。

不幸的是,又到了月末,到了给仆人发工资的时间。但这个仆人很奇怪,它可能想要至少x块钱,并且当LYK凑不出恰好x块钱时,它不会找零钱给LYK。

LYK知道这个x一定是1~n之间的正整数。当然抠门的LYK只想付给它的仆人恰好x块钱。但LYK只有若干的金币,每个金币都价值一定数量的钱(注意任意两枚金币所代表的钱一定是不同的,且这个钱的个数一定是正整数)。LYK想带最少的金币,使得对于任意x,都能恰好拼出这么多钱。并且LYK想知道有多少携带金币的方案总数。

具体可以看样例。

 

输入格式(dream.in)

第一行一个数n,如题意所示。

 

输出格式(dream.out)

输出两个数,第一个数表示LYK至少携带的金币个数,第二数表示方案总数。 

 

输入样例

6

 

输出样例

3 2

 

样例解释

LYK需要至少带3枚金币,有两种方案,分别是{1,2,3},{1,2,4}来恰好得到任意的1~n之间的x。

 

输入样例2

10

 

输出样例2

4 8

 

数据范围

对于30%的数据n<=10。

对于60%的数据n<=100。

对于100%的数据n<=1000。

 

思路:求方案总数 我们可以考虑 搜索 或者 dp

   DFS(int num,int sum,int lim)

   num 设为第i个金币 sum为当前已有的金币总数 lim为上一个金币的数量 也是当前最大的金币数量

   每次枚举下一个的金币代表的钱的值 可以有60分 再加点玄学优化 可以A掉

   dp的话 

   我们不妨设 dp[i][j][k] 表示 有了i个金币 金币和为j 上一个金币数为k的 方案数

   显然 dp[i][j][k] 是由 dp[i-1][j-x][x] 转移而来 x为上一个的金币大小

   时间复杂度为O(n^2) 显然是足够的

   dp[i][j][k] 可以用滚动数组来优化一下或者直接去掉第一维

 1 #include <cmath>
 2 #include <cctype>
 3 #include <cstdio>
 4 #define max(x,y) ((x) < (y) ? (y) : (x))
 5 
 6 int n,t,ans;
 7 
 8 void DFS(int num,int sum,int lim) {
 9     if(num == t) {
10         if((sum << 1) + 1 < n) return;
11         ans += (sum << 1) + 1 - max(n,lim + sum + 1) + 1;
12         return;
13      }
14      for(int i = lim + 1; i<= sum + 1; ++ i) DFS(num + 1,sum + i, i);
15 }
16 
17 int main(int argc,char**argv) {
18     freopen("dream.in","r",stdin);
19     freopen("dream.out","w",stdout);
20     
21     scanf("%d",&n);
22     t = log2(n) + 1;
23     
24     DFS(1,0,0);
25     printf("%d %d\\n",t,ans);
26     return 0;
27 }
DFS
 1 #include <cmath>
 2 #include <cstdio>
 3 #include <cctype>
 4 #define min(x,y) ((x) < (y) ? (x) : (y))
 5 
 6 const int MAXN=1010;
 7 
 8 int n,t,ans;
 9 
10 int dp[2][MAXN][MAXN];
11 
12 int main(int argc,char**argv) {
13     freopen("dream.in","r",stdin);
14     freopen("dream.out","w",stdout);
15     
16     scanf("%d",&n);
17     t = log2(n) + 1;
18     dp[1][1][1] = 1;
19     for(int i = 2; i <= t; ++i)
20       for(int j = 1; j <= n; ++j)
21         for(int k = 1; k <= n; ++k)
22           if(dp[(i - 1)&1][j][k]) {
23               for(int l = k + 1; l <= j + 1; ++l) 
24                 dp[i&1][min(n, j + l)][l] += dp[(i - 1)&1][j][k];
25           }
26     for(int i = 1; i <=n ; ++i)
27       ans += dp[t&1][n][i];
28     printf("%d %d\\n",t,ans);
29     return 0;
30 }
DP

T3 动态规划(dp)

动态规划(dp)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK在学习dp,有一天它看到了一道关于dp的题目。

这个题目是这个样子的:一开始有n个数,一段区间的价值为这段区间相同的数的对数。我们想把这n个数切成恰好k段区间。之后这n个数的价值为这k段区间的价值和。我们想让最终这n个数的价值和尽可能少。

例如6个数1,1,2,2,3,3要切成3段,一个好方法是切成[1],[1,2],[2,3,3],这样只有第三个区间有1的价值。因此这6个数的价值为1。

LYK并不会做,丢给了你。

 

输入格式(dp.in)

第一行两个数n,k。

接下来一行n个数ai表示这n个数。

 

输出格式(dp.out)

一个数表示答案。 

 

输入样例

10 2

1 2 1 2 1 2 1 2 1 2

 

输出样例

8

 

数据范围

对于30%的数据n<=10。

对于60%的数据n<=1000。

对于100%的数据1<=n<=100000,1<=k<=min(n,20),1<=ai<=n。

其中有30%的数据满足ai完全相同均匀分布在所有数据中。

 

思路:当然还是dp (题目都说了嘛)

   不妨设 dp[i][j] 表示前i个数中 切了j刀的 最小值

   转移为 dp[i][j] = min(dp[i][j], dp[k][j-1] + f[k+1][i]) 

   k 为枚举的断点 f[i][j] i~j这段区间内 相同数的对数 

   复杂度为O(n^2) 

   由于 n是小于1e5的 显然要TLE 

   这时候 由1D1D动态规划优化 用分治来优化dp可以做到 O(k*n*logn) 

   1D1D 优化我不懂就不解释了 想看的点击链接即可

 1 #include <cstdio>
 2 #include <cctype>
 3 #include <cstring>
 4 #define min(x,y) ((x) < (y) ? (x) : (y))
 5 
 6 const int MAXN=1010;
 7 
 8 int n,m;
 9 
10 int dp[MAXN][MAXN],f[MAXN][MAXN],a[MAXN],sum[MAXN];
11 
12 inline void read(int&x) {
13     int f = 1;register char c = getchar();
14     for(x = 0;!isdigit(c);c ==\'-\'&&(f = -1),c = getchar());
15     for(;isdigit(c);x = x * 10 + c - 48,c = getchar());
16     x = x * f;
17 }
18 
19 int main(int argc,char**argv) {
20     freopen("dp.in","r",stdin);
21     freopen("dp.out","w",stdout);
22     
23     read(n);read(m);
24     for(int i = 1; i <= n; ++i) read(a[i]);
25     
26     for(int i = 1; i <= n; ++i) {
27         ++sum[a[i]];
28         for(int j = i + 1; j <= n; ++j) 
29           f[i][j] = f[i][j-1] + sum[a[j]],++sum[a[j]];
30         memset(sum,0,sizeof sum);
31     }
32     
33     memset(dp,127/3,sizeof dp);
34     for(int i = 0; i <= n; ++i) dp[i][0]=0;
35     for(int i = 1; i <= n; ++i) {
36         dp[i][1] = f[1][i];
37         for(int j = 2; j <= min(i,m); ++j)
38           for(int k = 0; k < i; ++k) 
39             dp[i][j] = min(dp[i][j], dp[k][j-1] + f[k+1][i]);
40     }
41     
42     printf("%d\\n",dp[n][m]);
43     return 0;
44 }
60分dp代码
 1 #include<cstdio>
 2 #include<cstring>
 3 
 4 using namespace std;
 5 
 6 typedef long long LL;
 7 
 8 #define N 100001
 9 
10 LL tot;
11 
12 int a[N];
13 
14 int cnt[N],L,R;
15 
16 LL f[N],g[N];
17 
18 void move(int l,int r)
19 {
20     while(L>l) --L,tot+=cnt[a[L]],cnt[a[L]]++;
21     while(L<l) cnt[a[L]]--,tot-=cnt[a[L]],L++;
22     while(R>r) cnt[a[R]]--,tot-=cnt[a[R]],R--;
23     while(R<r) ++R,tot+=cnt[a[R]],cnt[a[R]]++;
24 }
25 
26 void work(int l,int r,int opl,int opr)
27 {
28     if(opl>opr) return;
29     int mid=opl+opr>>1;
30     LL mi=1e18; int pos;
31     for(int i=l;i<=r;i++)
32     if(i<mid)
33     {
34         move(i+1,mid);
35         if(tot+f[i]<mi) mi=tot+f[i],pos=i;
36     }
37     g[mid]=mi;
38     work(l,pos,opl,mid-1);
39     work(pos,r,mid+1,opr);
40 }
41 
42 int main()
43 {
44     freopen("dp.in","r",stdin);
45     freopen("dp.out","w",stdout);
46     int n,k;
47     scanf("%d%d",&n,&k);
48     for(int i=1;i<=n;i++) scanf("%d",&a[i]);
49     f[0]=0;
50     for(int i=1;i<=n;i++) f[i]=1e18;
51     while(k--)
52     {
53         memset(cnt,0,sizeof(cnt));
54         tot=0; L=1; R=0;
55         work(0,n-1,1,n);
56         for(int i=1;i<=n;i++) f[i]=g[i],g[i]=0;
57     }
58     printf("%d",f[n]);
59 }
1D1D优化

 

 

 

以上是关于2017 济南集训DAY1.AF的主要内容,如果未能解决你的问题,请参考以下文章

cogs2745[济南集训 2017] 求gcd之和解题报告

noip济南集训-10.1上午

noip济南集训-10.1上午

济南集训20191001解题报告

济南集训随机分数

QB学堂济南游记