寒假周练第一轮
Burglar and Matches
#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include<algorithm>
//#include <bits/stdc++.h>
using namespace std;
//const int MAX=2*1e8+5;
//int dp[MAX];//还可以拿i盒火柴能拿到的最大火柴数
struct node{
int x;//每个容器x个火柴盒
int y;//每个盒子火柴数字量
bool operator<(const node& n)const{
if(y==n.y)return x<n.x;
return y<n.y;
}
bool operator>(const node& n)const{
if(y==n.y)return x>n.x;
return y>n.y;
}
}a[25];
bool cmp(node n1,node n2){
return n1.y>n2.y;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,m;
cin>>n>>m;
for(int i=1;i<=m;i++){//m个容器
cin>>a[i].x>>a[i].y;
}
sort(a,a+n,greater<node>());
//sort(a,a+m,cmp);
int cnt=0;
for(int i=0;i<m;i++){
if(n>=a[i].x){
cnt+=a[i].x*a[i].y;
n-=a[i].x;
}
else{
cnt+=n*a[i].y;
break;
}
}
cout<<cnt;
return 0;
}
仰天大哭 TT
讲讲运算符重载
1、对于algorithm里的sort函数，有第三个参数 是规定排序规则的
之前熟悉的是自己定义的cmp函数
最近看了STL想用运算符重载，结果就 懵的一批
经过疯狂提交测试，
单单重载>再sort(a,a+m); 就报这种天杀的错
bool operator>(const node& n)const{
if(y==n.y)return x>n.x;
return y>n.y;
}
……
sort(a,a+m);
可以选择搭配 sort(a,a+m，greater());
有点像STL里的比如map，priority_queue容器自动排序
priority_queue<int,vector,greater >大顶堆
map<int,int, less >根据键值排序
bool operator>(const node& n)const{
if(y==n.y)return x>n.x;
return y>n.y;
}
……
sort(a,a+m，greater<node>());
如果同时重载 > 和 < ,那么直接sort(a,a+m);倒是不会出什么编译错误，只是默认按升序排列了
更新：
好叭，我又遇见了这个错误，之前搞错了。这次的问题是重载了<,但是用了小顶堆，priority_queue<node, vector ,greater >Q;又报了图片中可怕的错误。经过测试，这次的结论是：当使用sort，map，priority_queue这些默认自定排序的容器或者函数时，如果自己写了运算符重载，一定要按照它们自动排序的依据。比如，sort默认升序，就是要用到小于号，必须要重载小于号，再比如小顶堆，priority_queue<node, vector ,greater >Q;大的把小的推上去，需要用到比较符>,如果只是重载了小于号就会报错，可以单单重载大于号，也就是写一个运算符重载函数并不会改变默认排序顺序，需要自己加参数，比如sort的第三个参数greater（），而根据其默认排序规则，一定要定义该排序规则。有一个小技巧，比如sort默认按小于号排序，一定要对小于号进行运算符重载，但如果我们想将其降序排列，可以加上第三个参数再重载大于号，也可以偷懒不加参数，直接在重载小于号规则时内容改为大于号的规则
bool operator<(const node& n)const{
if(len==n.len)return cost>n.cost;
else return len>n.len;
}
priority_queue<node> Q;
上下两种组合都是小顶堆
bool operator>(const node& n)const{
if(len==n.len)return cost<n.cost;
else return len<n.len;
}
};
priority_queue<node, vector<node> ,greater<node> >Q;
2、
sort( a,a+len);
这个len我一直把m搞错成n，拜托这里数组长度是m，眼睛也看不到
3、一开始手一哆嗦就想写dp，先开了个巨大的数组
const int MAX=2*1e8+5;
int dp[MAX];//还可以拿i盒火柴能拿到的最大火柴数
否掉之后，觉得声明没什么大碍，就 Memory Limit Exceed了 TT
Goldbach’s Conjecture
一个偶数总能分解成两个质因数，如果很多种分解方式，输出相差最大的两个加数
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
//int a[1000005];//全局变量初始0
bool isprime(int x){
int p=(int)sqrt((double)x)+1;
for(int i=2;i<=p;i++){
if(x%i==0)return false;
}
return true;
}
int main(){
// ios::sync_with_stdio(false);
// cin.tie(0);
// for(int i=3;i<1000000;i+=2){
// if(isprime(i))a[i]=1;
// }
int n;//一个偶数分解成奇数的质数
scanf("%d",&n);
while(n){
for(int i=3;i<=n/2;i+=2){
if(isprime(i)&&isprime(n-i)){
// cout<<n<<" = "<<i<<" + "<<n-i<<endl;
printf("%d = %d + %d\n",n,i,n-i);
break;
}
}
scanf("%d",&n);
}
return 0;
}
先判断了前一百万个数是否是奇的质数并存在数组里，后面直接到数组查就行，TLE了
还是 来了一个数再判断两个加数，万一来很多次输入呢 不是很服
还有，下次拜托相信
ios::sync_with_stdio(false);
cin.tie(0);
Balance
钩子分布在坐标轴上坐标已知有正有负（在平衡点原点两端），一系列重物全部要挂上去保证平衡，问平衡的挂法（//对于w[i]从a数组中选几个系数，使得相加为0（求余为0）
为了规避负数，不管是取模还是取绝对值都不行的
余数为0的状态是有余数为非零数的状态递推过来的，
用秋雨的方法会打乱 余数为非零数的状态，负的和正的混在一块儿了
最大力矩 202015，对于相加和为负数的情况也要记录下来，不存在负数下标就把下标普遍增大7500
状态递推类比 糖果 那题，这种想法特别通
若某种状态存在，能通过这种状态推出哪种状态
#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
using namespace std;
int a[25];
int w[25];
int dp[25][15000];
//对于前i个数(搭配系数)相加和为j的情况 存在几种,由于和有正有负，
//不存在负的下标，对一个很大的数字求余
//const int mod=100000;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
//必须用上所有重物,有几种平衡方法，不一定用上所有钩子
int m,n;
cin>>m>>n;
for(int i=1;i<=m;i++){
cin>>a[i];//钩子距离平衡点的距离
}
for(int i=1;i<=n;i++){
cin>>w[i];//重物的重量
}
memset(dp,0,sizeof(dp));
dp[0][7500]=1;//不挂重物
//对于w[i]从a数组中选几个系数，使得相加为0（求余为0）
for(int i=1;i<=n;i++){
for(int j=0;j<=15000;j++){//有下面那条判断，j大于7500才会利用1进循环
if(dp[i-1][j])
for(int k=1;k<=m;k++)
// dp[i][(mod+(j+a[k]*w[i])%mod)%mod]++;
// dp[i][abs(j+a[k]*w[i])]+=dp[i-1][j];
dp[i][j+a[k]*w[i]]+=dp[i-1][j];
}
}
//为了规避负数，不管是取模还是取绝对值都不行的
//余数为0的状态是有余数为非零数的状态递推过来的，
//用秋雨的方法会打乱 余数为非零数的状态，负的和正的混在一块儿了
cout<<dp[n][7500];
//cout<<-1%1000<<endl;
//cout<<1%1000<<endl;
//cout<<0%1000<<endl;
return 0;
}
Monitor
原先显示器的尺寸为a ∗ b,现在要求比例x:y, ，同时要使得显示器的面积尽可能的大,输出裁剪后的显示器
#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include<algorithm>
//#include <bits/stdc++.h>
using namespace std;
int gcd(int a,int b){//最大公因数
if(a%b==0)return b;
return gcd(b,a%b);//a%b<b
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
long long int a,b,x,y;//2*1e9 int也够了
//long long 能表示19位数，无符号整数最多表示10位数的范围
cin>>a>>b>>x>>y;
// int divisor=gcd(x,y);
int divisor=__gcd(x,y);
x/=divisor;
y/=divisor;
if(a<x||b<y){
cout<<"0 0";
return 0;
}
int p=a/x;
int q=b/y;
int ratio=min(p,q);//p,q都是大于1的，越小越接近1
cout<<x*ratio<<" "<<y*ratio;
return 0;
}
Just 动态拉动一下x,y这个比例的框框，在原来ab的框架内 这个框框的哪一条边越接近ab框架，这时的面积显然最大
显然裁剪后的显示器尺寸为 kxky,显然要追求k尽量大 越接近ab框，a/kx或者是b/ky越小（越接近1啦），那么此时的k最大
Radar Installation
#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include <math.h>
#include<algorithm>
//#include <bits/stdc++.h>
using namespace std;
struct node{
double xl;
double xr;
bool operator <(const node& n)const{
if(xl==n.xl)return xr<n.xr;
return xl<n.xl;
}
}a[1005];//每个岛受控的雷达范围，为啥要double，double=sqrt(double)
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,d;
int t=0;
while(cin>>n>>d){
if(n==0&&d==0)break;
t++;
double x,y;
int flag=0;
for(int i=0;i<n;i++){
cin>>x>>y;
if(y>d)flag=1;
a[i].xl=x-sqrt(d*d-y*y);
a[i].xr=x+sqrt(d*d-y*y);
}
if(flag){
cout<<"Case "<<t<<": "<<"-1"<<endl;
continue;
}
sort(a,a+n);
int cnt=1;
int l=a[0].xl;
int r=a[0].xr;
for(int i=1;i<n;i++){
if(a[i].xl>=l&&a[i].xr<=r){
l=a[i].xl;
r=a[i].xr;
}
else if(a[i].xl<r&&a[i].xr>r){
l=a[i].xl;
}
else if(a[i].xl>r){
l=a[i].xl;
r=a[i].xr;
cnt++;
}
}
cout<<"Case "<<t<<": "<<cnt<<endl;
}
return 0;
}
Human Gene Functions
#include<iostream>
#include<stdio.h>
#include <stdlib.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include <map>
using namespace std;
int dp[105][105];//s1的前i个字符与s2前j个字符最长公共序列
int score[6][6]={{5,-1,-2,-1,-3},
{-1,5,-3,-2,-4},
{-2,-3,5,-2,-2},
{-1,-2,-2,5,-1},
{-3,-4,-2,-1,0}};
map<char,int> mp;
int get(char r,char c){
int row=mp[r];
int col=mp[c];
return score[row][col];
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
mp['A']=0;mp['C']=1;mp['G']=2;mp['T']=3;mp['-']=4;
int t;
cin>>t;
int len1,len2;
string s1,s2;
// char s1[105];
// char s2[105];
//即便两个字符串长度不相等也没关系啦，不用考虑string后面没有字符了
//也不是真的向字符串中添加—,只不过遇到不匹配的字符时,用-与它匹配从而
//得分，也不用考虑怎么得分多，递推过程中在不断比较了
while(t--){
//两个字符相等得分最高，优先找公共序列
cin>>len1>>s1;
cin>>len2>>s2;
//scanf("%d %s",len1,s1);
//scanf("%d %s",len2,s2);
//一上来就要用dp[i-1][j-1]，为防止越界必先初始化
memset(dp,0,sizeof(dp));
dp[0][0]=0;
for(int i=1;i<=len1;i++){
dp[i][0]=get(s1[i-1],'-')+dp[i-1][0];//只能i减一咯，s1[i]拉出来比较
}
for(int i=1;i<=len2;i++){
dp[0][i]=get('-',s2[i-1])+dp[0][i-1];
}
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
// if(s1[i]==s2[j])
// dp[i][j]=max(dp[i-1][j-1]+get(s1[i-1],s2[j-1]),dp[i][j]);
// else{
dp[i][j]=max(dp[i][j-1]+get('-',s2[j-1]),dp[i-1][j]+get(s1[i-1],'-'));
dp[i][j]=max(dp[i-1][j-1]+get(s1[i-1],s2[j-1]),dp[i][j]);
// dp[i][j-1]+get('-',s2[j])s1前i个和s2前j-1个假设已求出最优解，
// s2第j个只能拉出来比较了
// }
}
}
cout<<dp[len1][len2]<<endl;
}
return 0;
}
1、求公共子序列呀这种设计序列里面递归的状态用以前i个字符结尾为状态
2、初始化一般（预置dp数组）一般是针对一个序列没有字符这种
3、dp数组表示的状态是前i个字符，那么dp数组是从1开始遍历的，0没有意义且已经初始化用来递推后面的情况了，请注意前i个字符对应的是str【i-1】
4、不像仅仅求公共子序列那样，分字符是否相等的情况来为dp数组赋值，不可，要考虑所有情况取最大值，相等时取到的是局部最优解，全局最优解可能要放弃这个相等的匹配的点，因此无论是否相等，都要考虑
相等匹配和放弃相等匹配与’-'匹配得到的分数
//last but node least,可能真是太罗嗦了，runtime error
461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
