[ NOIP 2002 ] TG
\(\\\)
\(\#A\) 均分纸牌
有\(N\)堆纸牌，每堆有若干张，但纸牌总数必为\(N\)的倍数。可以在任一堆上取若干张纸牌，然后移动给其左右任意一侧的纸牌堆，求将所有的牌堆牌数都变为平均值最少移动次数。
- \(N\in [0,100]\)
- 把所有数减掉平均数，自左往右扫描，只要当前数不为\(0\)，就将这个数加给右侧的数，累加计数器。
- 如果加上了一个负数，代表从右侧的堆移动给了左侧，正数则相反。
#include<cmath>
#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 110
#define R register
#define gc getchar
using namespace std;
inline int rd(){
int x=0; char c=gc();
while(!isdigit(c)) c=gc();
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
return x;
}
int ave,ans,a[N];
int main(){
int n=rd();
for(R int i=1;i<=n;++i) ave+=(a[i]=rd());
ave/=n;
for(R int i=1;i<=n;++i) a[i]-=ave;
for(R int i=1;i<=n;++i){
ans+=(abs(a[i])>0); a[i+1]+=a[i];
}
printf("%d\n",ans);
return 0;
}
\(\\\)
\(\# B\) 字串变换
给定两个字符串\(A,B\)，以及\(N\)个映射\(U_i\rightarrow V_i\)，问是否能在十次操作之内通过子串映射的方式将\(A\)改为\(B\)。
- \(len_A,len_B\in [1,20]\)，\(N\in [1,20]\)
- 为了找到最少次数可以考虑\(BFS\)，每次找到一个位置，替换，次数加一加入队列，第一个找到的数为答案。
- 为了避免重复搜索同一个串，可以使用\(map\)判断，字符串处理上要注意
string自带的函数真**强。
#include<map>
#include<cmath>
#include<queue>
#include<cstdio>
#include<cctype>
#include<string>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define R register
#define N 30
using namespace std;
int tot=1,res;
string a,b,org[N],trs[N];
map<string,int> mp;
queue<pair<string,int> > q;
inline string check(string s,int p,int k){
string res="";
if(p+org[k].size()-1>s.size()) return res;
for(R int i=0;i<org[k].size();++i)
if(s[p+i]!=org[k][i])return res;
s.replace(p,org[k].size(),trs[k]);
return s;
}
int main(){
cin>>a>>b;
while(cin>>org[tot]>>trs[tot]) ++tot;
q.push(make_pair(a,0));
while(!q.empty()){
int u=q.front().second;
string su=q.front().first; q.pop();
if(!mp[su]) mp[su]=u;
else continue;
if(u>10) break;
if(su==b){res=u;break;}
for(R int i=0;i<su.size();++i)
for(R int j=1;j<=tot;++j){
string sv=check(su,i,j);
if(sv=="") continue;
q.push(make_pair(sv,u+1));
}
}
if(res) printf("%d\n",res);
else puts("NO ANSWER!");
return 0;
}
\(\\\)
\(\#C\) 自由落体
在高为\(H\)的天花板上有\(n\)个小球，体积不计，位置分别为\(0,1,2,…,n-1\)。
在地面上有一个小车（长为\(L\)，高为\(K\)，距原点距离为\(S_1\)）。
已知小球下落距离计算公式为d\(=0.5 \times g \times (t^2)\)，其中\(g=10\)，\(t\)为下落时间。地面上的小车以速度\(V\)前进。
小车与所有小球同时开始运动，当小球距小车的距离\(\le 0.0001\)时，即认为小球被小车接受（小球落到地面后不能被接受），计算小车能接受到多少个小球。
- \(1\le H,S_1,V,L,K,n\le 100000\)
- 解公式，小车在球落地前最远能到达的位置为\(S_2=S_1-V\times \sqrt\frac{2H}{g}\)
- 最早能接到球且最靠后的位置为\(S_3=S_1-V\times \sqrt\frac{2(H-K)}{g}+L\)
- 判断区间\([S2,S3]\bigcap[1,n]\)内的整点个数即可，注意精度的限制。
#include<cmath>
#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define R register
using namespace std;
typedef double db;
double eps=1e-4;
int main(){
db h,s,v,l,k,n;
scanf("%lf%lf%lf%lf%lf%lf",&h,&s,&v,&l,&k,&n);
double t1=sqrt(h/5),t2=sqrt((h-k)/5);
double s1=s-t1*v,s2=s-t2*v+l;
int resl=(int)ceil(max(s1-eps,(double)0)),resr=floor(min(n-1,s2+eps));
printf("%d\n",max(0,resr-resl+1));
return 0;
}
\(\\\)
\(\#D\) 矩形覆盖
给出\(N\)个第一象限的整点，求至多用\(K\)个矩形将其全部覆盖，矩形面积和最小是多少。
矩形可以是点或线，此时面积为\(0\)，但所选矩形不可出现面积相交、边相交、顶点相同的情况。
- \(N\in [1,50]\)，\(K\in [1,4]\)
\(DFS:\)
- 直接钦定每一个点属于哪一个矩形即可，剪枝如下：
- 每一层判断当前矩形中是否出现不合法情况
- 当前面积超过已经搜到过的答案
- 判断有交可以通过分别判断两个维度各自是否有交再去与得到。
#include<cmath>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define N 60
#define R register
#define gc getchar
#define inf 2000000000
using namespace std;
int n,k,res=inf,l[5],r[5],u[5],d[5];
struct point{int x,y;}p[N];
inline int rd(){
int x=0; bool f=0; char c=gc();
while(!isdigit(c)){if(c=='-')f=1;c=gc();}
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
return f?-x:x;
}
inline bool check(){
for(R int i=0;i<k;++i)
for(R int j=0;j<i;++j){
bool y=((u[i]>=d[j]&&u[i]<=u[j])||(u[j]>=d[i]&&u[j]<=u[i]));
bool x=((r[i]>=l[j]&&r[i]<=r[j])||(l[i]>=l[j]&&l[i]<=r[j]));
if(x&&y) return 1;
}
return 0;
}
void dfs(int x,int sum){
if(check()||sum>=res) return;
if(x>n){res=sum;return;}
for(R int i=0;i<k;++i){
int lsts=(l[i]==inf?0:(r[i]-l[i])*(u[i]-d[i]));
int lstl=l[i],lstr=r[i],lstu=u[i],lstd=d[i];
l[i]=min(l[i],p[x].x); r[i]=max(r[i],p[x].x);
d[i]=min(d[i],p[x].y); u[i]=max(u[i],p[x].y);
dfs(x+1,sum-lsts+(r[i]-l[i])*(u[i]-d[i]));
l[i]=lstl; r[i]=lstr; u[i]=lstu; d[i]=lstd;
}
}
int main(){
n=rd(); k=rd();
for(R int i=0;i<k;++i){l[i]=d[i]=inf;r[i]=u[i]=-inf;}
for(R int i=1;i<=n;++i){p[i].x=rd();p[i].y=rd();}
dfs(1,0);
printf("%d\n",res);
return 0;
}
\(DP:\)
- 本方法已被证明不是完全正确的，但可以通过当年的数据，由于思想可以借鉴所以还是写一写。
- 首先，按照横坐标为第一关键字，纵坐标为第二关键字排序，设\(f[i][j][k]\)为从第\(i\)个点覆盖到第\(j\)个点用\(k\)个矩形所需的最小面积和。
- 类区间\(DP\)的思想，枚举断点和两侧的矩形个数，暴力更新。
- 注意到这样做得到的矩形都是并排的，所以我们需要将坐标系转\(\frac{\pi}{2}\)再做一遍。
- 当\(4\)个矩形时即可构造数据卡掉这个情况，只需要让横纵向答案都不是并排的即可。
#include<cmath>
#include<cctype>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define N 60
#define R register
#define gc getchar
#define inf 2000000000
using namespace std;
int n,m,f[N][N][5];
struct point{int x,y;}p[N];
inline int rd(){
int x=0; bool f=0; char c=gc();
while(!isdigit(c)){if(c=='-')f=1;c=gc();}
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=gc();}
return f?-x:x;
}
inline bool cmp(point x,point y){
return (x.x==y.x)?x.y<y.y:x.x<y.x;
}
int main(){
n=rd(); m=rd();
for(R int i=0;i<n;++i){p[i].x=rd();p[i].y=rd();}
sort(p,p+n,cmp);
memset(f,0x3f,sizeof(f));
for(R int i=0;i<n;++i)
for(R int j=i+1;j<n;++j){
int l=inf,r=-inf;
for(R int k=i;k<=j;++k){l=min(l,p[k].y);r=max(r,p[k].y);}
f[i][j][1]=(r-l)*(p[j].x-p[i].x);
}
if(m==1){printf("%d\n",f[0][n-1][1]);return 0;}
for(R int i=n-1;i>=0;--i)
for(R int j=i+1;j<n;++j)
for(R int k=2;k<=m;++k)
for(R int p=i+1;p<j;++p)
for(R int t=1;t<k;++t)
if(f[i][j][k])f[i][j][k]=min(f[i][j][k],f[i][p][t]+f[p+1][j][k-t]);
else f[i][j][k]=f[i][p][t]+f[p+1][j][k-t];
int res=f[0][n-1][m];
for(R int i=0;i<n;++i) swap(p[i].x,p[i].y);
sort(p,p+n,cmp);
memset(f,0x3f,sizeof(f));
for(R int i=0;i<n;++i)
for(R int j=i+1;j<n;++j){
int l=inf,r=-inf;
for(R int k=i;k<=j;++k){l=min(l,p[k].y);r=max(r,p[k].y);}
f[i][j][1]=(r-l)*(p[j].x-p[i].x);
}
if(m==1){printf("%d\n",f[0][n-1][1]);return 0;}
for(R int i=n-1;i>=0;--i)
for(R int j=i+1;j<n;++j)
for(R int k=2;k<=m;++k)
for(R int p=i+1;p<j;++p)
for(R int t=1;t<k;++t)
if(f[i][j][k])f[i][j][k]=min(f[i][j][k],f[i][p][t]+f[p+1][j][k-t]);
else f[i][j][k]=f[i][p][t]+f[p+1][j][k-t];
printf("%d\n",min(res,f[0][n-1][m]));
return 0;
}
