USACO 2016 open Bronze 解题报告

                                       Diamond Collector(Bronze1)
         奶牛Bessie很喜欢闪亮亮的东西（Baling~Baling~），所以她喜欢在她的空余时间开采钻石！她现在已经收集了N颗不同大小的钻石（N<=1000），现在她想在谷仓的陈列架上摆放一些钻石。
    Bessie想让这些陈列架上的钻石保持相似的大小，所以她不会把两个大小相差K以上的钻石同时放在陈列架上（如果两颗钻石的大小差值为K，那么它们可以同时放在陈列架上）。现在给出K，请你帮Bessie确定她最多可以放多少颗钻石在陈列架上。
 
输入格式（diamond.in）:
    第一行输入两个值N和K（0<=K<10,000)。
         接下来N行，每行是一个整数，分别表示第1~N颗钻石的大小。
         数据保证钻石的大小为正数且不超过10,000.
 
输出格式（diamond.out）：
         输出仅一个数，为Bessie能在陈列架上摆的钻石数的最大值。
 
输入样例：
5 3
1
6
4
3
1
 
输出样例：
4

这题是一道水题，就简单带过吧。

首先来排个序，这样的话会更加方便计算。

然后枚举放上去的钻石的最小值ai，而且，Bessie更加想放最多的钻石，所以，还要再计算一遍钻石的重量在ai到ai+k之间的有多少个（用一个while或for就可以了）。

最后输出枚举的最大值就可以了。

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

int n,k;
int i,j;
int sum,ans;
int a[100100];
int main()
{
freopen("diamond.in","r",stdin);
freopen("diamond.out","w",stdout);

scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);

sort(a+1,a+n+1);//排序


for(i=1;i<=n;i++)//枚举最小值
{
sum=1;//注意要=1，因为最小值也要算上

for(j=i+1;j<=n;j++)//计算与最小值小于等于k的个数
{
if(a[j]-a[i]>k) break;
sum++;
}

ans=max(ans,sum);//求最大值
}

printf("%d",ans);
return 0;
}
//其实：这一道题可以用单点队列来实现，只不过数据不需要，只用O(n^2)就可以了。

Bronze2
         farmer john 认为他们家需要更多的装饰品。在访问本地的中国商店时，他找到了一个他想采购且可以十分合适地放在他的壁炉上的易损的玻璃奶牛。
         这个奶牛饰品的形状是用一个N*N的字符矩阵描述的（如下图）。图中字符‘#’是奶饰品的一部分而字符‘.’则不是。
        ...............
        ...............
        ...............
        #..#...........
        ####...........
        ############...
        .##.#########..
        ....#######.##.
        ....##...##....
        ....##...##....
        ...............
        ...............
        ...............
        ...............
        ...............
    不幸的是，正当FJ可以买下这件饰品时，一只公牛冲过这家商店且打碎了FJ的饰品和柜中的不少饰品。FJ的饰品裂成了2半，且很快在总共K个洒落在地上的碎片之中被混淆了。每一个K中的碎片都用一个N*N的字符矩阵描述，就像原来那个饰品。
    请帮助FJ算出哪两个K中的碎片是他需要重新拼合在一起的。幸运的是，他的饰品的碎片在掉在地上后并没有翻转。所以FJ只需要将碎片水平地或垂直地拼合在一起，使它们紧密结合。如果他找到了这两个正确的碎片，他可以用任意上述的一种方法让它们重新构成原来的饰品。原来的饰品中的每一个‘#’都代表着两个碎片中的确切的‘#’（意思就是这两个碎片在拼合的过程中，不应当有任何的‘#’重叠，且和原饰品完全一样）
    当任何一个碎片中的‘#’漏出原来的N*N矩阵时，碎片不可以被拼合。每一个碎片的形状不一定要和其他‘#’连在一起。尽管如此，如果有一个碎片的形状是支离破碎的，它也一定要和原来的饰品中的一部分对应才可以拼合。
    输入：
    第一行是N，K两个数。接下来的N行描述的是原来饰品的形状。再接下来的K*N行描述的是每一个碎片。
    输出：
    输出两个可以组成原来饰品的碎片的编号（两个从1到k的整数）保证有解。两个输出的数字必须以从小到大排序。
    样例：
4 3
####
#..#
#.##
....
.#..
.#..
##..
....
####
##..
#..#
####
....
.###
.#..
.#..
 
样例输出：
1 3
数据规模：
3≦N≦8
3≦K≦10

这题是一道考我们智商和编程能力的题目。

一，我们先来理顺一下题目的意思。

题目是说，在这1~k个碎片当中（不能把碎片翻转），它们当中有两个能拼合成题目要求的饰品，并输出这两个饰品的编号（从小到大）。

二，分析

因为N和K太小，6,7重循环没有问题。

1，为了方便，我们可以把饰品及碎片边边无用的东西删掉。时间复杂度O（n^3）

2，然后，我们枚举要组合的碎片。O(n^2);

     把一个固定不动，另一个与其进行拼合。还是O(n^2);

         判断是否与饰品相等。O(n^2);（其实，这里可以用hash或其他方法O(1)判断）

总时间复杂度O(n^6+n^3);

#include <cstdio>
#include <cstring>
#include <windows.h>
#include <cstdlib>
using namespace std;

int n,k;
int n1,n2;
struct _char{
char s[20][20];
char ss[20][20];
int ss1,ss2;

bool pd(char st[20])
{
for(int i=0;i<n;i++) if(st[i]==1) return 0;
return 1;
}

void cut()
{
int u,d,l,r;
bool bo;

for(u=0;u<n;u++)
if(!pd(s[u])) break;
for(d=n-1;d>=0;d--)
if(!pd(s[d])) break;

for(l=0;l<n;l++)
{
bo=1;
for(int i=0;i<n;i++) if(s[i][l]==1){ bo=0;break;}
if(bo==0) break;
}
for(r=n-1;r>=0;r--)
{
bo=1;
for(int i=0;i<n;i++) if(s[i][r]==1){ bo=0; break;}
if(bo==0) break;
}
ss1=d-u+1;
//if(ss1-1<n1) ss1=n1;
ss2=r-l+1;
//if(ss2-1<n2) ss2=n2;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++) ss[i][j]=0;
for(int i=0;i<ss1;i++)
for(int j=0;j<ss2;j++)
ss[i][j]=s[i+u][j+l];
}
};
_char s,st;
_char a[100];
void change(_char &x)
{
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
if(x.s[i][j]=='#') x.s[i][j]=1;
else x.s[i][j]=0;
}

bool check(_char x,_char y)
{
bool boo;

char sss[20][20];

for(int k1=0;k1<=n+3;k1++)
for(int k2=0;k2<=n+3;k2++)
{
memset(sss,0,sizeof(sss));
boo=1;
for(int i=0;i<x.ss1;i++)
for(int j=0;j<x.ss2;j++)
sss[i][j]=x.ss[i][j];
for(int i=0;i<y.ss1;i++)
for(int j=0;j<y.ss2;j++)
    sss[i+k1][j+k2]+=y.ss[i][j];
 
for(int i=0;i<s.ss1;i++)
for(int j=0;j<s.ss2;j++)
if(sss[i][j]!=s.ss[i][j])
boo=0;
if(boo==1) return true;
}
return false;


}

int main()
{

freopen("bcs.in","r",stdin);
freopen("bcs.out","w",stdout);

char sts[20][20];
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++) scanf("%s",s.s[i]);
change(s);
s.cut();
n1=s.ss1; n2=s.ss2;
for(int i=0;i<k;i++)
{
for(int j=0;j<n;j++)
scanf("%s",a[i].s[j]);
change(a[i]);
a[i].cut();

}

for(int i1=0;i1<k;i1++)
{

for(int j1=0;j1<k;j1++)
if(j1!=i1)
{

if(check(a[i1],a[j1]))
{
if(j1>i1) printf("%d %d",i1+1,j1+1);
else printf("%d %d",j1+1,i1+1);
return 0;
}
}
}

return 0;
}

Bronze3


农夫约翰的N(3<=N<=50000)头牛被定在了平面内的不同的位置。他想用栅栏(平行于x和y轴)围住所有的牛。他想这个栅栏尽可能小(牛在边界上也被视作围住)。


他因为牛奶产量低而感到经费紧张，所以他想卖掉一头牛再围起剩下的牛。请算出栅栏围出的最小面积。


输入：


第一行输入n


剩下2-n+1行，输入每头牛的位置。坐标在1...40000范围内。


输出：

最小面积。


示例


input：


4


2 4


1 1


5 2


17 25


output：


12

这道题也是一道很水的题，先写个数据：

 

题目说，要去掉一头牛，并且要使栅栏的面积最小，最简单的，就是用枚举来解决这道问题。先把他们分别按x,y轴的大小来排序，并用O(1)时间算出去掉这头牛之后的最小面积。

#include <cstdio>
#include <algorithm>
#include <iostream>
using namespace std;
int n,ans=0x7fffffff-100;
int a[100010],b[100010],x[100010],y[100010];
int x1,x2,y1,y2;
int main()
{
freopen("reduce.in","r",stdin);
freopen("reduce.out","w",stdout);

scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d",&a[i],&b[i]);
x[i]=a[i]; y[i]=b[i];
}

sort(a+1,a+n+1);
sort(b+1,b+n+1);

for(int i=1;i<=n;i++)
{
if(x[i]==a[1]) x1=a[2]; else x1=a[1];
if(x[i]==a[n]) x2=a[n-1]; else x2=a[n];
if(y[i]==b[1]) y1=b[2]; else y1=b[1];
if(y[i]==b[n]) y2=b[n-1]; else y2=b[n];
ans=min(ans,(x2-x1)*(y2-y1));
}

printf("%d",ans);
return 0;
}