所以续集总是无穷尽的，开头却消失不见。
然而并没有什么。
上题。
1.Bookstore
题目描述
在遥远的汪星球，小W开了一家书店。
这家书店推出促销活动，即每次顾客可以选择三本书，然后可以免去其中最便宜的那本书的价格（也就是只需要支付最贵的两本书的价格之和的钱，就能买到这三本书）。当然，如果顾客选择的书不足三本，那么就只能付全部的价钱了。
现在，有一个顾客挑选了 n 本书，这个顾客想要知道，自己最少付多少钱可以买到全部的书？
输入格式
输入 n+1 行，第一行一个整数 n ，表示顾客要买的书的本书。
接下来 n 行，每行一个整数，表示每本书的价钱。
输出格式
输出一行，表示顾客最少要付多少钱。
样例数据
输入
4
3
2
3
2
输出
8
备注
【数据规模与约定】
对于 50% 的数据，n≤2000。
对于 100% 的数据，1≤n≤100000，1≤ci≤100000。
其实是一道很水的模拟题。
要想省的钱最多，则先排序，然后从最贵的三件开始每三件衣服付贵的两件的钱。
最后再加上无法凑出三件的衣服的全价，即最低价格的一件或两件衣服。
代码如下。
#include<iostream>
#include<cstring>
#include<string>
#include<cstdlib>
#include<cstdio>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
int n;
int a[100003];
long long ans,ans1,ans2;
int main()
{
//freopen("bookstore.in","r",stdin);
//freopen("bookstore.out","w",stdout);
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
sort(a+1,a+n+1);
if(n<3)
for(int i=1;i<=n;i++)
ans+=a[i];
else if(n==3)
{
ans+=a[3];
ans+=a[2];
}
else if(n>3)
{
int k=n%3;
if(k==0)
{
for(int i=1;i<=n;i=i+3)
{
ans+=a[i+1];
ans+=a[i+2];
}
}
else if(k!=0)
{
for(int i=1;i<=k;i++)
ans1+=a[i];
for(int i=k+1;i<=n;i=i+3)
{
ans2+=a[i+1];
ans2+=a[i+2];
}
ans=ans1+ans2;
}
}
cout<<ans<<endl;
return 0;
}2.Table
题目描述
给定一个 n×m 的矩阵，行列均从 1 开始标号。
一个矩阵被认为是稳定的，当且仅当对于任意的 2≤i≤n，第 i 行的数的和不小于第 i−1 行的数的和，且最后一行的数的和小于等于 m ，并且要求矩阵中所有的元素都是非负的。
求所有 n×m 的稳定矩阵的方案数，答案对 109 取模。
输入格式
第一行一个整数 T ，表示数据组数。
每组数据一行两个整数 n，m 。
输出格式
输出 T 行，每行一个整数，表示方案数。
样例数据
输入
3
1 1
2 2
2 3
输出
2
25
273
备注
【数据规模与约定】
对于 30% 的数据，n,m≤3。
对于 60% 的数据，n,m≤50。
对于 100% 的数据，1≤n,m≤2000；1≤T≤10。
其实第一次读真心没读懂题，样例一个都没看懂。
然后突然反应过来说的是非负数，那么0应该也算。
复行数十步，豁然开朗。土地平旷，屋舍俨然。
用dp。
先预处理，f[i][j]表示i个数，和为j的方案数。可以将i个数和为j看作是j个1分成i堆。
嗯，可以用组合数（杨辉三角）更新。
然后，g[i][j]表示第i行，和为j的方案数。
由于前面的每一列数都和后面有关系，状态转移时可用前缀和优化。
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#define mod 1000000000
using namespace std;
int t,n,m,ans=0;
long long f[2010][2010],sum[2010][2010],cnt[2010][2010];
int main()
{
//freopen("table.in","r",stdin);
//freopen("table.out","w",stdout);
for(int i=1;i<=2000;i++)
{
sum[i][0]=cnt[i][0]=1;
sum[1][i]=cnt[1][i]=1; //预处理。
}
for(int i=1;i<=2000;i++)
for(int j=1;j<=2000;j++)
{
cnt[i][j]=(cnt[i][j-1]+cnt[i-1][j])%mod;
sum[i][j]=(sum[i][j-1]+cnt[i][j])%mod;
}
cin>>t;
for(int i=1;i<=t;i++)
{
cin>>n>>m;
memset(f,0,sizeof(f));
for(int i=0;i<=m;i++)
f[1][i]=sum[m][i];
for(int i=2;i<=n;i++)
for(int j=0;j<=m;j++) //状态转移。
f[i][j]=(f[i][j-1]+f[i][j]+cnt[m][j]*f[i-1][j])%mod;
ans=f[n][m]%mod;
cout<<ans<<endl;
}
return 0;
}3.Board
题目描述
给出这样一棵“二叉树”：
每个节点有左右两个儿子，并如下定义每个节点的高度：假设父亲节点的高度为 h ，那么他的两个儿子的节点的高度都是 h + 1 ，相同高度的所有节点称作一层。
每个节点的左儿子的子树都在右儿子的子树的左边，每一层相邻的两个节点之间有一条边。
下面是一个例子：
每一条图上的路径用一个字符串表示，字符串中的每一个字符表示一个移动。字符仅包含如下五种：
1：表示移动到当前节点的左儿子
2：表示移动到当前节点的右儿子
U：表示移动到当前节点的父亲节点
L：表示移动到当前节点同层的左边的节点（保证当前节点在这一层中不是最左边的节点）
R：表示移动到当前节点同层的右边的节点（保证当前节点在这一层中不是最右边的节点）
用一条路径来表示这条路径的终点，例如路径：221LU 就表示上图中的节点 A 。
给出两条路径，你的任务是求出着两条路径的终点之间的最短路。
输入格式
输入两行，每行一个字符串，分别表示两条路径。
输出格式
输出一行一个整数，表示两条路径的终点之间的最短路。
样例数据
输入
221LU （终点即为图中A点）
12L2（终点即为图中B点）
输出
3
备注
【数据规模与约定】
用 D 表示所有经过的节点中，深度最大的节点的深度；S 表示输入字符串的最大长度。
对于 10% 的数据，D≤10。
对于 30% 的数据，D≤50。
对于 50% 的数据，D≤1000。
对于 70% 的数据，D≤20000。
对于 100% 的数据，D≤100000；S≤100000。
题意不难理解，五个操作各有含义。
其实不论如何都要先将两点至于同一深度，然后再同时往上跳，最终得到最优解。
给树标号，设一个节点标号为k，则其左儿子标号为k×2，右儿子为k×2+1。
转换成二进制，则左儿子是在末尾加0，右儿子是在末尾加1。
则向上走时抹去末尾得数，向左下走时末尾加0，向右下走时末尾加1。
向右或向左走时，加减1。
由于有些可以直接加减。有些要进退位，又进退位的必为连在一起的几个数字，所以标记那一段数字，用线段树维护进位退位。
当跳到同一层时，距离即为标号差。
（代码过于繁琐，直接上题解）
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
struct node{
int lazy;
int summary;
int length;
}trans[270000];
int string_s[100003],string_t[100003],string_s_n,string_t_n;
void put(int x)
{
int num=0;
char c[12];
do
{
c[++num]=(x%10)+48;
x/=10;
}while(x);
while(num) putchar(c[num--]);
putchar('\n');
}
void build_a_tree(int left,int right,int now)
{
trans[now].length=right-left+1;
trans[now].lazy=trans[now].summary=0;
if(left==right) return;
int middle=(left+right)>>1;
build_a_tree(left,middle,now<<1);
build_a_tree(middle+1,right,now<<1|1);
}
void add_lazy(int now,int lazy)
{
trans[now].lazy=lazy;
trans[now].summary=(lazy-1)*trans[now].length;
}
void push_down(int now)
{
if(trans[now].lazy)
{
add_lazy(now<<1,trans[now].lazy);
add_lazy(now<<1|1,trans[now].lazy);
trans[now].lazy=0;
}
}
void update(int now)
{
trans[now].summary=trans[now<<1].summary+trans[now<<1|1].summary;
}
void modify(int left,int right,int now,int x,int y,int z)
{
if(right<x||y<left) return;
if(x<=left&&right<=y) return add_lazy(now,z);
int middle=(left+right)>>1;
push_down(now);
modify(left,middle,now<<1,x,y,z);
modify(middle+1,right,now<<1|1,x,y,z);
update(now);
}
int query_left(int left,int right,int now,int x)
{
if(x<left) return 0;
if(trans[now].summary==trans[now].length) return 0;
if(left==right) return trans[now].summary==0 ? left : 0;
int middle=(left+right)>>1;
push_down(now);
int ret=query_left(middle+1,right,now<<1|1,x);
if(!ret) ret=query_left(left,middle,now<<1,x);
return ret;
}
int query_right(int left,int right,int now,int x)
{
if(x<left) return 0;
if(trans[now].summary==0) return 0;
if(left==right) return trans[now].summary==1 ? left : 0;
int middle=(left+right)>>1;
push_down(now);
int ret=query_right(middle+1,right,now<<1|1,x);
if(!ret) ret=query_right(left,middle,now<<1,x);
return ret;
}
void tree_export(int left,int right,int now,int x,int *_string)
{
if(left>x) return;
if(left==right)
{
_string[left]=trans[now].summary;
return;
}
int middle=(left+right)>>1;
push_down(now);
tree_export(left,middle,now<<1,x,_string);
tree_export(middle+1,right,now<<1|1,x,_string);
}
void read(int *_string,int &string_n)
{
char *character =new char[100003];
scanf("%s",character+1);
int char_length=strlen(character+1);
build_a_tree(1,char_length,1);
string_n=0;
for(int i=1,j=char_length;i<=j;++i)
{
switch(character[i])
{
case '1':
{
++string_n;
modify(1,char_length,1,string_n,string_n,1);
break;
}
case '2':
{
++string_n;
modify(1,char_length,1,string_n,string_n,2);
break;
}
case 'U':
{
--string_n;
break;
}
case 'L':
{
int position=query_right(1,char_length,1,string_n);
modify(1,char_length,1,position+1,string_n,2);
modify(1,char_length,1,position,position,1);
break;
}
case 'R':
{
int position=query_left(1,char_length,1,string_n);
modify(1,char_length,1,position+1,string_n,1);
modify(1,char_length,1,position,position,2);
break;
}
}
}
tree_export(1,char_length,1,string_n,_string);
delete [] character;
}
int main()
{
read(string_s,string_s_n);
read(string_t,string_t_n);
int _summary=abs(string_s_n-string_t_n);
int _n=min(string_s_n,string_t_n);
int distance=0;
int answer=_n<<1;
bool flag=1;
for(int i=1;i<=_n;++i)
{
if(!flag)
{
distance<<=1;
if(string_s[i]==0) ++distance;
if(string_t[i]==1) ++distance;
}
if(string_s[i]!=string_t[i]&&flag)
{
flag=0;
if(string_s[i]==1) swap(string_s,string_t);
}
if(distance>answer) break;
answer=min(answer,distance+!flag+2*(_n-i));
}
put(_summary+answer);
return 0;
}
凑合着看吧。
就酱。
来自2017.7.20
——我认为return 0，是一个时代的终结。
384
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
