2014ACM/ICPC亚洲区北京站 上交命题

A http://acm.hdu.edu.cn/showproblem.php?pid=5112

输入n个时刻和位置，问那两个时刻间速度最快。

解法：按照时间排序，然后依次求相邻两个之间的速度，速度=ds/dt

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=1e4+10;
struct G{
    int t,x;
    friend bool operator <(const G &a,const G &b){
        return a.t<b.t;
    }
}g[M];
int main(){
    int t,n;
    while(~scanf("%d",&t)){
        int cas=1;
        while(t--){
            scanf("%d",&n);
            for(int i=0;i<n;i++){
                scanf("%d%d",&g[i].t,&g[i].x);
            }
            sort(g,g+n);
            double ans=0;
            for(int i=0;i<n-1;i++){
                ans=max(ans,abs(g[i].x-g[i+1].x)*1.0/(g[i+1].t-g[i].t));
            }
            printf("Case #%d: %.2f
",cas++,ans);
        }
    }
    return 0;
}

D http://acm.hdu.edu.cn/showproblem.php?pid=5115

有n只狼排成一排，每一步消灭一只，每次消灭花费当前这只狼的a，以及左右两边最近的两只的b，ai+bleft+bright。问消灭所有狼最小花费。

解法：若暴力，可以n！，算花费取最小值。优化一点状态压缩，可以从二进制111-》000，最后dp【0】的最小值就是答案。复杂度2^n.再优化

定义dp【i】【j】表示消灭i到j最小花费。答案就是dp【1】【n】。转移时枚举i到j中最后一个被杀的，假设是k，那么转移就是

dp【i】【j】=min（dp【i】【j】，dp【i】【k-1】+dp【k+1】【j】+a【k】+b【i-1】+b【j+1】）；

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=256;
const int inf=0x3f3f3f3f;
int a[M],b[M],dp[M][M];
int main(){
    int t,n;
    while(~scanf("%d",&t)){
        int cas=1;
        while(t--){
            scanf("%d",&n);
            for(int i=1;i<=n;i++){
                scanf("%d",&a[i]);
            }
            for(int i=1;i<=n;i++){
                scanf("%d",&b[i]);
            }
            b[0]=b[n+1]=0;
            for(int i=1;i<=n;i++){
                for(int j=i;j<=n;j++){
                    dp[i][j]=inf;
                }
            }
            for(int len=1;len<=n;len++){
                for(int i=1;i+len-1<=n;i++){
                    for(int j=i;j<i+len;j++){
                        int cost=a[j]+b[i-1]+b[i+len];
                        if(j>i){
                            cost+=dp[i][j-1];
                        }
                        if(j<i+len-1){
                            cost+=dp[j+1][i+len-1];
                        }
                        dp[i][i+len-1]=min(dp[i][i+len-1],cost);
                    }
                }
            }
            printf("Case #%d: %d
",cas++,dp[1][n]);
        }
    }
    return 0;
}

H http://acm.hdu.edu.cn/showproblem.php?pid=5119

有40个数，问选一个子集异或之和大于等于m的有多少种选法。

解法：朴素算法，暴力所有子集验证答案，2^40的时间复杂度，01背包

定义dp【i】【j】表示前n个异或和为j的情况数，则答案为dp【n】【j】，j>=m。

转移就两个 ，选或者不选。

#include<cstdio>
typedef long long LL;
const int M=50;
int a[M];
LL dp[M][1<<20];
int main(){
    int t,n,m;
    while(~scanf("%d",&t)){
        int cas=1;
        while(t--){
            scanf("%d%d",&n,&m);
            for(int i=1;i<=n;i++){
                scanf("%d",&a[i]);
            }
            int big=1<<20;
            for(int i=0;i<=n;i++){
                for(int j=0;j<big;j++){
                    dp[i][j]=0;
                }
            }
            dp[0][0]=1;
            for(int i=0;i<=n;i++){
                for(int j=0;j<big;j++){
                    if(!dp[i][j]) continue;
                    dp[i+1][j^a[i+1]]+=dp[i][j];
                    dp[i+1][j]+=dp[i][j];
                }
            }
            LL ans=0;
            for(int j=m;j<big;j++){
                ans+=dp[n][j];
            }
            printf("Case #%d: %I64d
",cas++,ans);
        }
    }
    return 0;
}

I http://acm.hdu.edu.cn/showproblem.php?pid=5120

问两个圆环交的面积。

解法：容斥原理？算两个大圆面积交，扣掉左边大圆与右边小圆的交，再扣掉左边小圆与右边大圆的交，再把两个小圆的交加回来。

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
const double eps=1e-8;
const double pi=acos(-1.0);
struct point {
    double x,y;
} c1,c2;
double Distance(point p1,point p2) {
    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
}
point intersection(point u1,point u2,point v1,point v2) {
    point ret=u1;
    double t=((u1.x-v1.x)*(v1.y-v2.y)-(u1.y-v1.y)*(v1.x-v2.x)) /((u1.x-u2.x)*(v1.y-v2.y)-(u1.y-u2.y)*(v1.x-v2.x));
    ret.x+=(u2.x-u1.x)*t;
    ret.y+=(u2.y-u1.y)*t;
    return ret;
}
void intersection_line_circle(point c,double r,point l1,point l2,point& p1,point& p2) {
    point p=c;
    double t;
    p.x+=l1.y-l2.y;
    p.y+=l2.x-l1.x;
    p=intersection(p,c,l1,l2);
    t=sqrt(r*r-Distance(p,c)*Distance(p,c))/Distance(l1,l2);
    p1.x=p.x+(l2.x-l1.x)*t;
    p1.y=p.y+(l2.y-l1.y)*t;
    p2.x=p.x-(l2.x-l1.x)*t;
    p2.y=p.y-(l2.y-l1.y)*t;
}
void intersection_circle_circle(point c1,double r1,point c2,double r2,point& p1,point& p2) {
    point u,v;
    double t;
    t=(1+(r1*r1-r2*r2)/Distance(c1,c2)/Distance(c1,c2))/2;
    u.x=c1.x+(c2.x-c1.x)*t;
    u.y=c1.y+(c2.y-c1.y)*t;
    v.x=u.x+c1.y-c2.y;
    v.y=u.y-c1.x+c2.x;
    intersection_line_circle(c1,r1,u,v,p1,p2);
}
double xmult(point p1,point p2,point p0) {
    return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
double area_triangle(point p1,point p2,point p3) {
    return fabs(xmult(p1,p2,p3))/2;
}
int same_side(point p1,point p2,point l1,point l2) {
    return xmult(l1,p1,l2)*xmult(l1,p2,l2)>eps;
}
double area_circle_circle(point a,double r1,point b,double r2) {
    if(r1<eps||r2<eps)return 0.0;
    double temp=Distance(a,b);
    point p1,p2;
    double co1,co2,ret=0.0,du1,du2,z;
    if(temp+eps>=r1+r2) {
        return 0.0;
    } else if(temp-eps<=fabs(r1-r2)) {
        temp=min(r1,r2);
        return pi*temp*temp;
    } else {
        intersection_circle_circle(a,r1,b,r2,p1,p2);
        temp=Distance(p1,p2);
        co1=(r1*r1*2.0-temp*temp)/(2.0*r1*r1);
        du1=acos(co1);
        z=(r1*r1*du1/2.0-area_triangle(p1,p2,a));
        if(same_side(a,b,p1,p2)&&r1<r2)z=pi*r1*r1-z;
        ret+=z;
        co2=(r2*r2*2.0-temp*temp)/(2.0*r2*r2);
        du2=acos(co2);
        z=(r2*r2*du2/2.0-area_triangle(p1,p2,b));
        if(same_side(a,b,p1,p2)&&r2<r1)z=pi*r2*r2-z;
        ret+=z;
        return ret;
    }
}
int main() {
    int t;
    double r,R;
    while(~scanf("%d",&t)) {
        int cas=1;
        while(t--) {
            scanf("%lf%lf%lf%lf%lf%lf",&r,&R,&c1.x,&c1.y,&c2.x,&c2.y);
            printf("Case #%d: %.6f
",cas++,area_circle_circle(c1,R,c2,R)-area_circle_circle(c1,r,c2,R)-area_circle_circle(c1,R,c2,r)+area_circle_circle(c1,r,c2,r));
        }
    }
    return 0;
}

K http://acm.hdu.edu.cn/showproblem.php?pid=5122

输入n的一个排列，问最少多少次操作能将其从小到大排好序， 每次操作可以任意选一个数，不断的往后交换直至后一个大于他停止。

解法：首先选必须要从大往小选，这样最多n次就能排好序，就是逆序的情况。因为如果选个中间的，他往后换的过程可能会遇到一个较大的使得他停下，没达到需要到的位置，从大到小选就避免了这种情况，是最优的方法。问题转化为如何统计步数。我们定义一个需求need，表示当前需要选的数，定义一个指针p，表示当前位置，指针从最后一个位置开始，需求从n开始。每次迭代，若指针的位置的值a【p】恰好等于need，则我们不需要浪费步数，数就在他应该在的位置。若a【p】小于need，说明这个位置应该放的是need，我们需要消耗一步，将前面的need移动至此，但我们不需改动数组的值，因为改动的复杂度是on的。此时我们只需要记录ans++，need--，p不动。若a【p】大于need，说明这个值已经处理过了，p--。

#include<cstdio>
#include<algorithm>
using namespace std;
const int M=1e6+10;
int a[M];
int main(){
    int t,n;
    while(~scanf("%d",&t)){
        int cas=1;
        while(t--){
            scanf("%d",&n);
            for(int i=0;i<n;i++){
                scanf("%d",&a[i]);
            }
            int ans=0;
            int p=n-1;
            for(int i=n;i>=1;i--){
                if(a[p]==i){
                    p--;
                    continue;
                }
                if(a[p]>i){
                    p--;
                    i++;
                    continue;
                }
                ans++;
            }
            printf("Case #%d: %d
",cas++,ans);
        }
    }
    return 0;
}

end