所以續集總是無窮盡的，開頭卻消失不見。
然而並沒有什麼。
上題。
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，是一個時代的終結。