**acm虐我千百遍，我却待他如初见**
**枯木逢春不在茂，年少且惜镜边人**
做了这么多的acm题了，才发现自己的知识是多么的浅薄，多么的不堪一击，既然做了，现在就来总结吧。
现在就先总结一下ACM第二周
第二周------------贪心+基础动态规划+简单STL运用（栈，队列等）
第二周题很难，基本上不看看别人的思想，就不会发现自己的思想是多么的错误。
不多说了先看题吧！
1
涂奥最近迷上了吃鸡，房间有n个配件，每个配件有c(c<=1e3)的重量和v(v<=1e3)的价值，哇，涂奥捡了一个2级包，容量为s，所以涂奥最多当多肥的快递员呢？
Input
输入的第一行是T,
表示有一共要打T场比赛.
每组数据由三行组成.
第1行包含两个整数n和s
第2行包含n个整数,
表示每一个配件的价值.
第3行包含n个整数,
表示每个配件的重量.
Output 对每一组数据, 输出涂奥可以多肥.Sample Input1
10 10
1 3 5 7 9 11 13 15 17 19
19 17 15 13 11 9 7 5 3 1
Sample Output
51
#include<stdio.h>
#include<string.h>
int dp[1010][1010];
int p[1010],w[1010];
int qmax (int a,int b)
{ return a > b ? a : b;}
int main()
{ int N;
int i,k,l,v;
scanf ("%d",&N);
while (N--)
{
memset (dp,0,sizeof (dp));
scanf ("%d %d",&l,&v);
for (i = 1; i <= l; i++)
scanf ("%d",&w[i]);
for (i = 1; i <= l; i++)
scanf ("%d",&p[i]);
for (i = 1; i <= l; i++)
for (k = 0;k <= v; k++)
{
if (k >= p[i])
dp[i][k] = qmax (dp[i - 1][k],dp[i - 1][k - p[i]] + w[i]);
else
dp[i][k] = dp[i - 1][k];
}
printf ("%d\n",dp[l][v]);
}
return 0;
}
本题是一个典型的01背包问题，但是在写的时候要注意一些细节，当我把J从=0改成J=1开始的时候就错了，但是在编译器上没错，但是我又把动态规划表两种都打出来看了一下，发现一摸一样，哎，造化弄人啊，思考了一下，可能某些数据需要吧！（强行解释，最为致命！）
2.
可怜的POIUYTREWQ最近想买下dota2的商品，但是手头缺钱。他想起了之前看过的一部大片，觉得抢银行也许是个不错的选择。他认为，坏人被抓是因为没有预先规划。于是他在之前的几个月对各大银行进行了一次评估；
评估内容包括安全性和可盗窃金额：
他想知道在在某个风险系数下可以偷窃的最大金额
Input第一行给出了一个整数T, 表示有T组测试数据. 对于每一组数据，第一行给出了一个浮点数P, 表示POIUYTREWQ允许被抓的最大概率, 和一个整数N，表示他计划去抢劫的N个银行. 接下来N行, 每行给出一个整数数Mj和浮点数Pj.
抢劫银行 j 可获得 Mj 百万美金, 被抓的概率是 Pj .Output对于每组数据，每行输出一个整数，表示POIUYTREWQ在被抓概率小于P的情况下，可抢到的最多的金钱。
Notes and Constraints
0 < T <= 100
0.0 <= P <= 1.0
0 < N <= 100
0 < Mj <= 100
0.0 <= Pj <= 1.0
你可以认为每家银行都是独立的。Sample Input3
0.04 3
1 0.02
2 0.03
3 0.05
0.06 3
2 0.03
2 0.03
3 0.05
0.10 3
1 0.03
2 0.02
3 0.05
Sample Output
2
4
6
#include <stdio.h>
#include <string.h>
double max(double a,double b)
{
return a>b?a:b;
}
int a[10010];
double b[10010];
double dp[100000];
int main()
{
int t,k,i,j;
scanf("%d",&t);
while(t--)
{
double p;
int n,sum=0;
scanf("%lf %d",&p,&n);
for(i=0;i<n;i++)
{
scanf("%d %lf",&a[i],&b[i]);
sum+=a[i];
}
memset(dp,0,sizeof(dp));
dp[0]=1;
for(i=0;i<n;i++)
for(j=sum;j>=a[i];j--)
dp[j]=max(dp[j],dp[j-a[i]]*(1-b[i]));
for(i=sum;i>=0;i--)
{
if(1-dp[i]<p)
{
printf("%d\n",i);
break;
}
}
}
return 0;
}
这个题真的是害我良久
曾一度以为编译器出了问题，但是看了别人的思想，才发现是自己的思想都错了，本题确实是一个背包问题，一开始把被抓概率当成体积，结果发现打错特错，本题正确解法是将银行总钱数看成体积，最小被抓概率，代表最大逃跑概率，所以只需DP最大逃跑概率就行，注意，概率和概率之间需要乘法！看代码就懂，当他不偷任何一家时，逃跑概率自然为1
在 ACM 能够开展之前，必须准备预算，并获得必要的财力支持。该活动的主要收入来自于 Irreversibly Bound Money (IBM)。思路很简单。任何时候，某位 ACM 会员有少量的钱时，他将所有的硬币投入到小猪储钱罐中。这个过程不可逆，因为只有把小猪储钱罐打碎才能取出硬币。在足够长的时间之后，小猪储钱罐中有了足够的现金，用于支付 ACM 活动所需的花费。
但是，小猪储钱罐存在一个大的问题，即无法确定其中有多少钱。因此，我们可能在打碎小猪储钱罐之后，发现里面的钱不够。显然，我们希望避免这种不愉快的情况。唯一的可能是，称一下小猪储钱罐的重量，并尝试猜测里面的有多少硬币。假定我们能够精确判断小猪储钱罐的重量，并且我们也知道给定币种的所有硬币的重量。那么，我们可以保证小猪储钱罐中最少有多少钱。
你的任务是找出最差的情形，即判断小猪储钱罐中的硬币最少有多少钱。我们需要你的帮助。不能再贸然打碎小猪储钱罐了！输入输入包含 T 组测试数据。输入文件的第一行，给出了 T 的值。
对于每组测试数据，第一行包含 E 和 F 两个整数，它们表示空的小猪储钱罐的重量，以及装有硬币的小猪储钱罐的重量。两个重量的计量单位都是 g (克)。小猪储钱罐的重量不会超过 10 kg (千克)，即 1 <= E <= F <= 10000 。每组测试数据的第二行，有一个整数 N (1 <= N <= 500)，提供了给定币种的不同硬币有多少种。接下来的 N 行，每行指定一种硬币类型，每行包含两个整数 P 和 W (1 <= P <= 50000，1 <= W <=10000)。P 是硬币的金额 (货币计量单位)；W 是它的重量，以 g (克) 为计量单位。输出对于每组测试数据，打印一行输出。每行必须包含句子 “The minimum amount of money in the piggy-bank is X.” 其中，X 表示对于给定总重量的硬币，所能得到的最少金额。如果无法恰好得到给定的重量，则打印一行 “This is impossible.” 。示例输入3
10 110
2
1 1
30 50
10 110
2
1 1
50 30
1 6
2
10 3
20 4
示例输出
The minimum amount of money in the piggy-bank is 60.
The minimum amount of money in the piggy-bank is 100.
This is impossible.
#include<stdio.h>
#include<string.h>
int min(int a, int b)
{
return a>b?b:a;
}
int v[506],m[506],dp[506][10006];
int main()
{
int t;
int i,j;
int b,n;
scanf("%d",&t);
while(t--)
{
memset(v,0,sizeof(v));
memset(m,0,sizeof(m));
memset(dp,0,sizeof(dp));
int a,b;
scanf("%d %d",&a,&b);
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d %d",&v[i],&m[i]);
}
for(int i=0;i<=n;i++)
{
for(int j=0;j<=b-a;j++)
dp[i][j]=100000000;
}
dp[0][0]=0;
for(int i=1;i<=n;i++)
{
for(int j=0;j<=b-a;j++)
{
if(m[i]>j)
{
dp[i][j]=dp[i-1][j];
}
else
{
dp[i][j]=min(dp[i-1][j],dp[i][j-m[i]]+v[i]);
}
}
}
if(dp[n][b-a]==100000000)
{
printf("This is impossible.\n");
}
else
printf("The minimum amount of money in the piggy-bank is %d.\n",dp[n][b-a]);
}
return 0;
}
这道题是一个多重背包问题，当然acm也讲过，也讲过优化，很裸的一道完全背包，讲存钱罐体积看成容量，存的钱看成价值，只不过讲MAX改成MIN就行，当然求最少初值当然得大一点，多大呢 自己试试，必要时学学无穷大怎么写！但是DP[0][0]得是0，因为体积价值当然是0
4.
Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, …
shows the first 11 ugly numbers. By convention, 1 is included. Write a program to find and print the 1500’th ugly number. Input There is no input to this program. Output Output should consist of a single line as shown below, with ‘’ replaced by the number computed. Sample Output The 1500’th ugly number is .
**这题目就是讲的是 从一开始 然后给他乘2 3 5 得到的数，然后这些数乘以2 3 5得到的数以此类推，得到的数排列一下求1500个数是多少
**
#include<stdio.h>
int min(int a,int b)
{
return a>b?b:a;
}
int main()
{
int ugly_number[1505] = {1};
int n2=0,n3=0,n5=0;
int i;
for(i=1;i<1500;i++)
{
for(n2=0;n2<i;n2++)
if(ugly_number[n2]*2>ugly_number[i-1]) break;
for(n3=0;n3<i;n3++)
if(ugly_number[n3]*3>ugly_number[i-1]) break;
for(n5=0;n5<i;n5++)
if(ugly_number[n5]*5>ugly_number[i-1]) break;
ugly_number[i]=min(ugly_number[n2]*2,ugly_number[n3]*3);
ugly_number[i]=min(ugly_number[i],ugly_number[n5]*5);
}
printf("The 1500'th ugly number is %d.\n",ugly_number[1499]);
return 0;
}
这个方法可谓只观简单，我本来还想用什么其他的，想也没想出来，要求第n个丑数，只需要将前N-1个丑数乘以2 3 5 就行，找出那个比N-1大且最小的那个丑数就是第N个，总之 ， 很棒 很棒 荧光棒！
5
给定几种不同面额的硬币若干枚，需要求的用这些硬币可以组成多少种范围在1~m的不同面额的组合。
Input输入包含多组数据，每组数据第一行有两个数字n(1 ≤ n ≤ 100)，m(m ≤ 100000)。第二行包含2n个数字, A1,A2,A3…An,C1,C2,C3…Cn (1 ≤ Ai ≤ 100000,1 ≤ Ci ≤ 1000)——Ai表示第i种硬币的面值，Ci表示第i种硬币的数量，输入以0 0结束。Output对于每组数据输出可能的组合数。Sample Input3 10
1 2 4 2 1 1
2 5
1 4 2 1
0 0
Sample Output
8
4
#include<stdio.h>
#include<string.h>
#include<string.h>
int max(int a,int b)
{
return a>b?a:b;
}
int dp[100100];
int a[100100],b[100100];
int main()
{
int i,j;
int k;
long long ans;
int n,m;
while (~scanf("%d %d", &n, &m) && n != 0 && m != 0)
{
ans=0;
memset(dp, 0, sizeof(dp));
for ( i = 1; i <= n; i++)
scanf("%d", &a[i]);
for ( i = 1; i <= n; i++)
scanf("%d", &b[i]);
dp[0] = 1;
for ( i = 1; i <= n; i++)
{
k = 1;
while (k <= b[i])
{
for ( j = m; j >= k * a[i]; j--)
{
dp[j] =max(dp[j - k * a[i]],dp[j]);
}
b[i] -= k;
k *= 2;
}
if (b[i] == 0)
continue;
for ( j = m; j >= b[i] * a[i]; j--)
{
dp[j] =max( dp[j - b[i] * a[i]],dp[j]);
}
}
for ( i = 1; i <= m; i++)
{
ans += dp[i];
}
printf("%lld\n",ans);
}
return 0;
}
这道题是多重背包问题，多重背包其实就是01背包，和完全背包的优化，我是不可能做出来的看了多重背包后才恍然小悟，想看的我就不多说了，给你网址
多重背包，完全背包
01背包
这两个讲的真的好，真香，值得一看！
6
现有 N 个大理石，每个大理石上写了一个非负整数。首先请你将这 N 块大理石按照它们上面所写数字的大小从小到大排序，然后按照排序后的顺序把这 N 个大理石从 1 ~ N 编号。之后请你回答 Q 个询问，每个询问问是否存在一个大理石上写着某个整数 x，如果存在，请你回答写着整数 x 的编号最小的大理石的编号，如果不存在，请你输出 x not found。Input有多组数据。
每组数据第一行包括两个整数 N，Q，当输入为 N = 0， Q = 0 时，表示结束。
否则接下来 Q 行，每一行包括一个数字 x，表示询问。Output对于每组测试数据，首先输出 “Case# XX”，XX 为测试数据编号，按读入顺序由 1 开始递增。
对于每组测试数据中的每一次询问，按如下规则输出：
`x found at y', if the first marble with number x was found at position y. Positions are numbered 1, 2,..., N.
`x not found', if the marble with number x is not present.
直接看样例你应该就懂了。Sample Input4 1
2
3
5
1
5
5 2
1
3
3
3
1
2
3
0 0
Sample OutputCASE# 1:
5 found at 4
CASE# 2:
2 not found
3 found at 3
#include<stdio.h>
#include<stdlib.h>
int cmp(const void *a, const void *b)
{
return *(int*)a - *(int*)b;
}
int a[10010];
int main()
{
int n,q,x,kase = 0;
int i;
while(scanf("%d %d",&n,&q) == 2 && n)
{
printf("CASE# %d:\n",++kase);
for( i = 0; i < n; i++)
{
scanf("%d",&a[i]);
}
qsort(a, n, sizeof(int), cmp);
while(q--)
{
scanf("%d",&x);
for(i=0;i<n;i++)
{
if(a[i]==x)
{
printf("%d found at %d\n", x, i+1);
break;
}
}
if(i==n)
{
printf("%d not found\n",x);
}
}
}
return 0;
}
这道题其实是一个难度比较弱的题，就是排序找数字，测试数据也比较弱，用上快排可以降低时间复杂度！然后就看代码吧！
小细节：scanf的返回值是 读入数的个数！嘿嘿
Most crossword puzzle fans are used to anagrams–groups of words with the same letters in different orders–for example OPTS, SPOT, STOP, POTS and POST. Some words however do not have this attribute, no matter how you rearrange their letters, you cannot form another word. Such words are called ananagrams, an example is QUIZ.
Obviously such definitions depend on the domain within which we are working; you might think that ATHENE is an ananagram, whereas any chemist would quickly produce ETHANE. One possible domain would be the entire English language, but this could lead to some problems. One could restrict the domain to, say, Music, in which case SCALE becomes a relative ananagram (LACES is not in the same domain) but NOTE is not since it can produce TONE.
Write a program that will read in the dictionary of a restricted domain and determine the relative ananagrams. Note that single letter words are, ipso facto, relative ananagrams since they cannot be ``rearranged'' at all. The dictionary will contain no more than 1000 words.
输入一些单词，找出所有满足如下条件的单词：该单词不能通过字母重排，得到输入文本的另外一个单词。在判断是否满足条件时，字母不分大小写，但在输出时应保留输入的大小写，按字典序排列。 Input
Input will consist of a series of lines. No line will be more than 80 characters long, but may contain any number of words. Words consist of up to 20 upper and/or lower case letters, and will not be broken across lines. Spaces may appear freely around words, and at least one space separates multiple words on the same line. Note that words that contain the same letters but of differing case are considered to be anagrams of each other, thus tIeD and EdiT are anagrams. The file will be terminated by a line consisting of a single #.
输入包含若干行，每行不超过80个字符，由一些单词组成。单词由不超过20个大小写字母组成。Output
Output will consist of a series of lines. Each line will consist of a single word that is a relative ananagram in the input dictionary. Words must be output in lexicographic (case-sensitive) order. There will always be at least one relative ananagram.Sample Inputladder came tape soon leader acme RIDE lone Dreis peat
ScAlE orb eye Rides dealer NotE derail LaCeS drIed
noel dire Disk mace Rob dries
#Sample OutputDisk
NotE
derail
drIed
eye
ladder
soon
英文题自我感觉难！！！！！！！！！题目意思就是输入一些单词，找出所有满足如下条件的单词：该单词不能通过字母重排，得到输入文本的另外一个单词。在判断是否满足条件时，字母不分大小写，但在输出时应保留输入的大小写，按字典序排列，多看几遍 就会带懂了
#include <stdio.h>
#include <string.h>
#define max 1001
char word[max][100],key[max][100],s[100],s1[100];
int a[max];
void change()//讲原字符串存入s,变为小写后的存入s1，然后将s1字母排序
{
int l=strlen(s),i,j;
for (i=0;i<l;i++)
if (s[i]<='Z') s1[i]=s[i]+32;
else s1[i]=s[i];
for (i=0;i<l-1;i++)
for (j=i+1;j<l;j++)
if (s1[i]>s1[j]) {s1[l]=s1[i];s1[i]=s1[j];s1[j]=s1[l];}
s1[l]='\0';
};
int pk(char s1[],char s2[])//字典顺序排序！相当于strcmp函数
{int l1=strlen(s1),l2=strlen(s2),i;
l1=l1<l2 ? l1:l2;
for (i=0;i<l1;i++)
{if (s1[i]>s2[i])
return 1;
if (s1[i]<s2[i])
return 0;
}
};
int main ()
{int sum=0,i,j,f;
while (scanf("%s",&s))
{
if (s[0]=='#') break;
change();
f=1;//标记相当于flag，
for (i=1;i<=sum;i++)
if (strcmp(key[i],s1)==0)//当相同时令a【i】=0表示有重复，然后直接跳出，把相同的标记为0；
{
f=0;
a[i]=0;
break;
}
if (f)//相同的话就是A[sum]标记为无重复，然后sum++准备和后面的比较
{
++sum;
a[sum]=1;
strcpy(word[i],s);//注意这里下标是[I]；
strcpy(key[i],s1);
}
}
for (i=1;i<sum;i++)
for (j=i+1;j<=sum;j++)
if (pk(word[i],word[j]))//按字典顺序输出，在变化时候，标记数组也要转换！
{strcpy(s,word[i]);strcpy(word[i],word[j]);strcpy(word[j],s);
a[0]=a[i];a[i]=a[j];a[j]=a[0];
}
for (i=1;i<=sum;i++)//输入有标记的，也就是无重复的
if (a[i])
puts(word[i]);
}
详细在代码中说过 ，请看代码！
n 个孩子在玩一个游戏。 孩子们站成一圈，按照顺时针顺序分别被标号为 1 到 n。开始游戏时，第一个孩子成为领导。 游戏进行 k 轮。 在第 i 轮中，领导会从他顺时针方向下一个孩子开始数 ai 个孩子。最后数到的那个孩子出局，再下一个孩子成为新的领导。
举个例子， 现在圈内还剩 [8, 10, 13, 14, 16]5个孩子，领导编号为 13 ， ai = 12。那么出局的孩子为 16 。第 8 个孩子成为下一个领导。
你需要写一个代码模拟这个过程，求出每轮比赛出局的孩子。
Input
第一行包含两个整数 n 和 k (2 ≤ n ≤ 100, 1 ≤ k ≤ n - 1).
第二行包含 k 个整数 a1, a2, …, ak (1 ≤ ai ≤ 109).
Output
输出 k 个整数，第 i 个整数表示第 i轮出局的孩子。
Example
Input
7 5
10 4 11 4 1
Output
4 2 5 6 1
Input
3 2
2 5
Output
3 2
Note
我们来看样例:
第一轮出局的孩子编号为 4 ，孩子 5 变成领导。
第二轮出局的孩子编号为 2 ，孩子 3 变成领导。
第三轮出局的孩子编号为 5 ，孩子 6 变成领导。
第四轮出局的孩子编号为 6 ，孩子 7 变成领导。
最后一轮出局的孩子编号为 1 ，孩子 3 变成领导。
#include<stdio.h>
int a[140];
int main()
{
int n,k,x;
scanf("%d %d",&n,&k);
int cnt,first=1,ans;
int i,j;
for(j=0;j<k;j++)
{
scanf("%d",&x);
cnt=x%(n-j);//求余数
if(cnt==0)
cnt=n-j;//如果是队长就得从最后一个人开始，因为是一个减法过程
for( i=first+1;;i++) //开始计数，从队长下一个人开始
{
if(i>n)//如果大于总人数就从头开始
i=1;
if(a[i]==0)//表示用i记录余数
cnt--;
if(cnt==0)//出局的人来了
{
a[i]=1;
ans=i;
for(int l=i+1;;l++)//确定下一位队长
{
if(l>n)//看此时是否是队尾
l=1;
if(!a[l])//看此人是否被淘汰
{
first=l;
break;
}
}
break;
}
}
printf("%d ",ans);
}
return 0;
}
这道题本来想用数组删除解决，但是发现数据太大，过不了，尴尬，这道题正确解法是比较贪心的，也就是模拟这个过程，用传的数去对每次人数取余,就是得到从上次开始计数开始的人数的下几个，这样一来，直接看代码！
9.
超市里有N个商品. 第i个商品必须在保质期(第di天)之前卖掉, 若卖掉可让超市获得pi的利润.
每天只能卖一个商品.
现在你要让超市获得最大的利润. Input多组数据.
每组数据第一行为一个整数N (0 <= N <= 10000), 即超市的商品数目
之后N行各有两个整数, 第i行为 pi, di (1 <= pi, di <= 10000)Output对于每一组数据, 输出当前条件下超市的最大利润Sample Input4
50 2
10 1
20 2
30 1
7
20 1
2 1
10 3
100 2
8 2
5 20
50 10
Sample Output80
185
Hint
Translated by shleodai
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct node
{
int p,d;
};//用结构体存入日期和价格
int n;
int vis[10005];
int main()
{
struct node a[10005],x;
int i,j,sum;
while(~scanf("%d",&n))
{
sum=0;
for(i=0;i<n;i++)
scanf("%d %d",&a[i].p,&a[i].d);
memset(vis,0,sizeof(vis));
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)//按照价格大小排列商品
{
if(a[i].p<a[j].p)
{
x=a[j];
a[j]=a[i];
a[i]=x;
}
}
for( i=0;i<n;i++)
{
for( j=a[i].d;j>=1;j--)//没件商品都在过期前一天出售，从价格最大的开始，然后将那个标记1
{
if(!vis[j])
{
vis[j]=1;
sum+=a[i].p;
break;
}
}
}
printf("%d\n",sum);
}
return 0;
}
这道题贪心算法题，从价格最大的开始，每件商品都按过期前买掉，思想之精华可谓棒棒棒！很贪心，很棒！
到此为止 ，其他 的题实在不会做，太菜了 ，去学习java，明天整理第一周的吧！
508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
