matrix_world_final_2013

A http://acm.hust.edu.cn/vjudge/contest/view.action?cid=98960#problem/A

题意：给一个正方形，四边上有A-Z带+-，如果是00就不能连任何的。如果两个正方形的边字母相同，正负号相反，就可以连起来。问给输入的n种，每种无限个，可否构成无限大的平面。给的正方形可以旋转或者对称的翻转。

解法：想要无限大，就想能否有几个正方形够成环了，构成环就可以无限延伸。如何判环可以拓扑排序，或者tarjan缩点。关键在建图。对于每个正方形，其中一条边的假设是A+，那么A-就可以通像这个正方形的另外3个符号。建一条有向边。

 //#define debug
 //#define txtout
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<cctype>
 #include<ctime>
 #include<iostream>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #include<stack>
 #include<map>
 #include<set>
 #define mt(a,b) memset(a,b,sizeof(a))
 using namespace std;
 typedef long long LL;
 const double eps=1e-;
 const double pi=acos(-1.0);
 const int inf=0x3f3f3f3f;
 const int M=4e4+;
 char a[M][];
 char str[][]= {"bounded","unbounded"};
 int n;
 vector<int> id;
 class Toposort { ///拓扑排序(矩阵) O(V^2)
     static const int MV=1e2+;///点的个数
     bool mat[MV][MV];
     int n,ret[MV],d[MV],i,j,k;
 public:
     void init(int tn) { ///传入点数,点下标0 开始
         n=tn;
         for(i=; i<n; i++)
             for(j=; j<n; j++)
                 mat[i][j]=false;
     }
     void add(int u,int v) {
         mat[u][v]=true;
     }
     bool solve() { ///无法完成排序,返回flase
         for(i=; i<n; i++) {
             d[i]=;
             for(j=; j<n; j++) {
                 d[i]+=mat[j][i];
             }
         }
         for(k=; k<n; k++) {
             for(i=; i<n; i++) {
                 if(!d[i]) break;
             }
             if(i==n) return false;
             d[i]=-;
             for(j=; j<n; j++) {
                 d[j]-=mat[i][j];
             }
             ret[k]=i;
         }
         return true;
     }
     int getvalue(int id) { ///0~n-1 中存着字典序最小的序列
         return ret[id];
     }
 } gx;
 int get_id(char a,char b){
     int result=a-'A';
     if(b=='-') result+=;
     return result;
 }
 int get_other(int a){
     if(a<) return a+; return a-;
 }
 int solve() {
     gx.init();
     for(int i=; i<n; i++) {
         id.clear();
         for(int j=;j<;j+=){
             if(a[i][j]=='') continue;
             id.push_back(get_id(a[i][j],a[i][j+]));
         }
         int len=id.size();
         for(int j=;j<len;j++){
             for(int k=j+;k<len;k++){
                 gx.add(get_other(id[j]),id[k]);
                 gx.add(get_other(id[k]),id[j]);
             }
         }
     }
     return !gx.solve();
 }
 int main() {
 #ifdef txtout
     freopen("in.txt","r",stdin);
     freopen("out.txt","w",stdout);
 #endif
     while(~scanf("%d",&n)) {
         for(int i=; i<n; i++) {
             scanf("%s",a[i]);
         }
         puts(str[solve()]);
     }
     return ;
 }

发现缩点模板没法判自环。

 //#define debug
 //#define txtout
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<cctype>
 #include<ctime>
 #include<iostream>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #include<stack>
 #include<map>
 #include<set>
 #define mt(a,b) memset(a,b,sizeof(a))
 using namespace std;
 typedef long long LL;
 const double eps=1e-;
 const double pi=acos(-1.0);
 const int inf=0x3f3f3f3f;
 const int M=4e4+;
 char a[M][];
 char str[][]= {"bounded","unbounded"};
 int n;
 vector<int> id;
 bool mat[][];
 class Tarjan { ///有向图强连通分量缩点O(V+E)
     static const int ME=1e4+; ///边的个数
     static const int MV=1e2+; ///点的个数
     int n,Index,Bcnt,num[MV],belong[MV],dfn[MV],low[MV];
     bool instack[MV];
     stack<int> s;
     void tarjan(int u) {
         dfn[u]=low[u]=++Index;
         instack[u]=true;
         s.push(u);
         int v;
         for(int i=g.head[u]; ~i; i=g.e[i].next) {
             v=g.e[i].v;
             if(!dfn[v]) {
                 tarjan(v);
                 low[u]=min(low[u],low[v]);
                 continue;
             }
             if(instack[v]) {
                 low[u]=min(low[u],dfn[v]);
             }
         }
         if(dfn[u]!=low[u]) return ;
         Bcnt++;
         do {
             v=s.top();
             s.pop();
             instack[v]=false;
             belong[v]=Bcnt;
             num[Bcnt]++;
         } while(u!=v);
     }
     struct G {
         struct E {
             int v,next;
         } e[ME];
         int le,head[MV];
         void init(int n) {
             le=;
             for(int i=; i<=n; i++) head[i]=-;
         }
         void add(int u,int v) {
             e[le].v=v;
             e[le].next=head[u];
             head[u]=le++;
         }
     } g;
 public:
     void init(int tn) { ///传入点数，点下标1 开始
         n=tn;
         g.init(n);
     }
     void add(int u,int v) {
         g.add(u,v);
     }
     void solve() {
         Index=Bcnt=;
         for(int i=; i<=n; i++) {
             num[i]=dfn[i]=low[i]=instack[i]=;
         }
         while(!s.empty()) s.pop();
         for(int i=; i<=n; i++) {
             if(!dfn[i]) {
                 tarjan(i);
             }
         }
     }
     int getbcnt() { ///强连通分量的个数
         return Bcnt;
     }
     int getbelong(int id) { ///属于哪个分量，分量下标1 开始
         return belong[id];
     }
     int getnum(int id) { ///某个分量的点的个数
         return num[id];
     }
 } gx;
 int get_id(char a,char b) {
     int result=a-'A';
     if(b=='-') result+=;
     return result;
 }
 int get_other(int a) {
     if(a<) return a+;
     return a-;
 }
 int solve() {
     mt(mat,);
     for(int i=; i<n; i++) {
         id.clear();
         for(int j=; j<; j+=) {
             if(a[i][j]=='') continue;
             id.push_back(get_id(a[i][j],a[i][j+]));
         }
         int len=id.size();
         for(int j=; j<len; j++) {
             for(int k=j+; k<len; k++) {
                 mat[get_other(id[j])][id[k]]=true;
                 mat[get_other(id[k])][id[j]]=true;
             }
         }
     }
     gx.init();
     for(int i=;i<;i++){
         for(int j=;j<;j++){
             if(!mat[i][j]) continue;
             if(i==j) return ;
             gx.add(i+,j+);
         }
     }
     gx.solve();
     return gx.getbcnt()!=;
 }
 int main() {
 #ifdef txtout
     freopen("in.txt","r",stdin);
     freopen("out.txt","w",stdout);
 #endif
     while(~scanf("%d",&n)) {
         for(int i=; i<n; i++) {
             scanf("%s",a[i]);
         }
         puts(str[solve()]);
     }
     return ;
 }

F http://acm.hust.edu.cn/vjudge/contest/view.action?cid=98960#problem/F

题意：有n台机器，每个机器由两个部分组成，每个部分需要k个电池，输入n，k，和2*n*k个电池的值。求如何分配电池，使得每个机器的差值d中最大的最小。差值d等于机器两部分电池的最小值之差。

解法：先把电池按照值小到大排序，二分答案d，判断是否可以满足，如果可以满足，则找更小的，如果不可以则找更大的，就能找到最小的d。判断满足即判断所有的机器差值都小于等于二分的差值即可。从小到大选择，如果相邻的两个差值满足，则直接将这两个座位一个机器的两部分，如果不满足，就将小的扔到之前已经满足的部分的后面。

 //#define debug
 //#define txtout
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<cctype>
 #include<ctime>
 #include<iostream>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #include<stack>
 #include<map>
 #include<set>
 #define mt(a,b) memset(a,b,sizeof(a))
 using namespace std;
 typedef long long LL;
 const double eps=1e-;
 const double pi=acos(-1.0);
 const int inf=0x3f3f3f3f;
 const int M=1e6+;
 int a[M];
 int n,k,m;
 bool judge(int mid){
     int save=,sum=;
     for(int i=;i+<m;i++){
         if(a[i+]-a[i]>mid){
             if(save==) return false;
             save--;
         }
         else{
             save+=*k-;
             sum++;
             if(sum==n) return true;
             i++;
         }
     }
     return false;
 }
 int solve(){
     sort(a,a+m);
     int L=,R=a[m-]-a[],result=R;
     while(L<=R){
         int mid=(L+R)>>;
         if(judge(mid)){
             result=mid;
             R=mid-;
         }
         else{
             L=mid+;
         }
     }
     return result;
 }
 int main(){
     #ifdef txtout
     freopen("in.txt","r",stdin);
     freopen("out.txt","w",stdout);
     #endif
     while(~scanf("%d%d",&n,&k)){
         m=*n*k;
         for(int i=;i<m;i++){
             scanf("%d",&a[i]);
         }
         printf("%d\n",solve());
     }
     return ;
 }

J http://acm.hust.edu.cn/vjudge/contest/view.action?cid=98960#problem/J

题意：圆与多边形的交

解法：不会，模板

 //#define debug
 //#define txtout
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<cmath>
 #include<cctype>
 #include<ctime>
 #include<iostream>
 #include<algorithm>
 #include<vector>
 #include<queue>
 #include<stack>
 #include<map>
 #include<set>
 #define mt(a,b) memset(a,b,sizeof(a))
 using namespace std;
 typedef long long LL;
 const double eps=1e-;
 const double pi=acos(-1.0);
 const int inf=0x3f3f3f3f;
 const int M=1e2+;
 struct point {
     double x,y;
 } p[M];
 double r;
 int n;
 class Area_of_circle_polygon {
     double xmult(point p1,point p2,point p0) { ///计算向量叉积(P1-P0)x(P2-P0)
         return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
     }
     double Square(double x) { ///平方
         return x*x;
     }
     double Distance(point a,point b) { ///平面两点距离
         return sqrt(Square(a.x-b.x)+Square(a.y-b.y));
     }
     double dmult(point p1,point p2,point p0) {
         return (p1.x-p0.x)*(p2.x-p0.x)+(p1.y-p0.y)*(p2.y-p0.y);
     }
     double help_cal(point a,point b,point c,double r,double C){
         double d=dmult(a,c,b);
         double x=xmult(a,c,b);
         return (d+sqrt(r*r*C*C-x*x))/C;
     }
     double help_again(double tS,double x,double C,double r,double B){
         return asin(tS*(-x/C)*/r/B)*r*r*0.5+tS*x/C;
     }
     double cal_area(point a,point b,point c,double r) {
         double A,B,C,x,y,tS;
         A=Distance(b,c);
         B=Distance(a,c);
         C=Distance(b,a);
         tS=xmult(a,b,c)*0.5;
         if(A<r&&B<r) return tS;
         if(A<r&&B>=r) {
             x=help_cal(a,b,c,r,C);
             return help_again(tS,x,C,r,B);
         }
         if(A>=r&&B<r) {
             y=help_cal(b,a,c,r,C);
             return help_again(tS,y,C,r,A);
         }
         if(fabs(xmult(a,b,c))>=r*C||dmult(b,c,a)<=||dmult(a,c,b)<=) {
             double x=xmult(a,b,c);
             double tmp=-asin(x/A/B);
             if(dmult(a,b,c)<){
                 if(x<){
                     tmp-=pi;
                 }
                 else{
                     tmp+=pi;
                 }
             }
             else{
                 tmp=-tmp;
             }
             return tmp*r*r*0.5;
         }
         x=help_cal(a,b,c,r,C);
         y=help_cal(b,a,c,r,C);
         double t1=help_again(tS,x,C,r,B);
         double t2=help_again(tS,y,C,r,A);
         return t1+t2-tS;
     }
 public:
     double solve(point p[],int n,point circle,double r) {///传入多边形点数组，点个数，圆心，半径
         double area=;
         for(int i=; i<n; i++) {
             area+=cal_area(p[i], p[(i+)%n], circle, r);
         }
         return area;
     }
 } gx;

 int main() {
 #ifdef txtout
     freopen("in.txt","r",stdin);
     freopen("out.txt","w",stdout);
 #endif
     point c;
     c.x=c.y=;
     while(~scanf("%d%lf",&n,&r)) {
         for(int i=; i<n; i++) {
             scanf("%lf%lf",&p[i].x,&p[i].y);
         }
         printf("%.9f\n",gx.solve(p,n,c,r));
     }
     return ;
 }

end