C++博客-acronix-随笔分类-qqy解题报告

USACO Friday the Thirteenth

acronix — Fri, 10 Sep 2010 13:40:00 GMT

//考察点: 纯模拟
//思路: 根据题目的意思努力计算天数在考虑到闰年的时候需要把二月份的天数更新
//提交情况: 悲剧的2WA 问题的根源是freopen语句错误文件名多了 file
//收获: 提交的时候文件名不是"file"+" "+"name" 而是"name"
//经验: 以后操作一个数组的时候一定要初始化一次用memset就行
//ACcode:

/*
ID: qiuqiyu1
PROB: friday
LANG: C++
*/
#include<stdio.h>
#include<memory.h>
#define BEGIN (1900)
#define FIRST_DAY (1)
int md[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};

bool isleap(int y)
{
    if(y%400 == 0 || (y%4==0 && y%100!=0)) return true;
    else return false;
}

int main()
{
    freopen("friday.in","r",stdin);
    freopen("friday.out","w",stdout);
    int N,sumday[8];
    scanf("%d",&N);
    int i,j,k,y;
    int p=FIRST_DAY;
    memset(sumday,0,sizeof(sumday));
    for(i=0;i<N;i++)
    {
        y=BEGIN+i;
        if(isleap(y)) md[2]=29;
        else md[2]=28;
        for(j=1;j<=12;j++)
        {
            for(k=1;k<=md[j];k++)
            {
                if(k==13) sumday[p%7]+=1;
                p++;
                //printf("%d\n",p%7);
            }
        }
    }
    p=FIRST_DAY;

    /*for(i=0;i<7;i++)
    {
        if(i!=0) printf(" ");
        printf("%d",sumday[i]);
    }
    printf("\n");*/

    printf("%d ",sumday[6]);
    for(i=0;i<6;i++)
    {
        if(i!=0) printf(" ");
        printf("%d",sumday[i]);
    }
    printf("\n");

    return 0;
}

acronix 2010-09-10 21:40 发表评论

USACO Greedy Gift Givers

acronix — Fri, 10 Sep 2010 13:39:00 GMT

//考察点: 结构体
//思路: 简单模拟注意要先减掉准备分配出去的钱然后再把余下的加回来
//提交情况: 1AC
//收获: p->mon+=mon/nf;是错误的写法 mon变成未定义的东西了如果要更新 p->mon 应该写成 p->mon=p->mon+p->mon/nf;
//经验: 以后编程的时候要注意结构体的使用
//ACcode:

/*
ID: qiuqiyu1
PROB: gift1
LANG: C++
*/
#include<stdio.h>
#include<string.h>
typedef struct element
{
    char nam[20];
    int mon;
}node;

node* find(node memlist[],int memlist_len,char nam_cnt[])
{
    int i;
    int n=memlist_len;
    node *a=memlist;
    char *b=nam_cnt;
    for(i=0;i<n;i++)
    {
        if(strcmp(b,a[i].nam)==0) return &a[i];
    }
    return NULL;// if not found
}

void dis_gift(node memlist[],int memlist_len, char nam[])
{
    char nam_f[20];
    int nm,nf;
    int n=memlist_len,i;
    node *p,*a=memlist;

    //scanf("%s",nam);
    scanf("%d%d",&nm,&nf);
    p=find(a,n,nam);
    (p->mon)-=nm;
    if(nf!=0)(p->mon)+=(nm%nf);
    for(i=0;i<nf;i++)
    {
        scanf("%s",nam_f);
        p=find(a,n,nam_f);
        (p->mon)+=(int)(nm/nf);
    }
}

int main()
{
    freopen("gift1.in","r",stdin);
    //freopen("gift1.out","w",stdout);
    node a[10];
    int n,i;
    char nam[20];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%s",a[i].nam);
        a[i].mon=0;
    }
    for(i=0;i<n;i++)
    {
        scanf("%s",nam);
        dis_gift(a,n,nam);
    }
    for(i=0;i<n;i++)
    {
        printf("%s %d\n",a[i].nam,a[i].mon);
    }
    return 0;
}

acronix 2010-09-10 21:39 发表评论

USACO Your Ride Is Here

acronix — Fri, 10 Sep 2010 13:38:00 GMT

//考察点: 文件操作
//思路: 写一个子函数用来计算每个单词的val就行
//提交情况: 1AC
//收获: 字符串数组最后有一个结束符不要算错长度
//经验
//ACcode:

/*
ID: qiuqiyu1
PROG: ride
LANG: C++
*/
#include<stdio.h>
#include<string.h>
int val(char a[])
{
    int pro,i,len;
    pro=1;
    len=strlen(a);
    for(i=0;i<len;i++)
    {
        pro=(pro*(a[i]-'A'+1))%47;
    }
    return pro;
}

int main()
{
    freopen("ride.in","r",stdin);
    freopen("ride.out","w",stdout);
    char a[7],b[7];
    scanf("%s",a);
    getchar();
    gets(b);
    printf(val(a)==val(b)?"GO\n":"STAY\n");
    return 0;
}

acronix 2010-09-10 21:38 发表评论

pku_1247 & boj_1361

acronix — Wed, 01 Sep 2010 12:32:00 GMT

//考点: 纯模拟
//思路: 只要枚举分割点然后发现只要记录到分割点前所有和顺便计算出总和sum就行求余下部分的和只需用到sum和dp[i]
//提交情况: 1AC 感动得热泪盈眶啊
//收获: 练习了求和知道怎样记录每个递加的过程
//经验: 写了代码之后要检查第一次写的时候就很冲动地把i++ 写成了 i+=2
//ACcode

#include<memory.h>
#include<stdio.h>
#define MAXN 31
int a[MAXN];
int dp[MAXN];
int main()
{
    int t,i;
    while(1)
    {
        scanf("%d",&t);
        if(t == 0) break;
        int sum=0;
        for(i=1;i<=t;i++)
        {
            scanf("%d",&a[i]);
            dp[i]=dp[i-1]+a[i];
        }
        sum=dp[t];
        bool flag = false;
        int mark;
        for(i=1;i<t;i++)
        {
            if(dp[i] == sum-dp[i])
            {
                flag = true;
                mark = i;
                break;
            }
        }
        if(flag == false) printf("No equal partitioning.\n");
        else  printf("Sam stops at position %d and Ella stops at position %d.\n",mark,mark+1);
        memset(dp,0,sizeof(dp));
    }
    return 0;
}

acronix 2010-09-01 20:32 发表评论

pku_1256 & boj_1343

acronix — Wed, 01 Sep 2010 11:35:00 GMT

//考察点: next_permutation的用法考察了设计cmp函数的能力
//思路只要写出满足条件的cmp函数就可以了利用奇偶性把大小写字母错开. 于是想到了cmp函数的书写方式
//提交情况 1WA 1AC 第一次错了是因为交错题目了!!
//收获: 学到了处理这种比较函数的方法如果还有一种A就可以乘以三然后再利用初始相位进行划分.
//经验: 写next_permutation的时候因为需要打印出最早的一个情况所以用的 do while 形式
//ACcode:

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
int f(char x)
{
    if('a'<=x && x<='z') return (x-'a'+1)*2;
    else return (x-'A')*2+1;
}
bool cmp(char x,char y)
{
    return f(x)<f(y);
}
int main()
{
    //freopen("pku_1256_in.txt","r",stdin);
    char a[15];
    int t;
    int n;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",a);
        n=strlen(a);
        sort(a,a+n,cmp);
        do
        {
            printf("%s\n",a);
        }while(next_permutation(a,a+n,cmp));
    }
    return 0;
}

acronix 2010-09-01 19:35 发表评论

pku_1046 & boj_1359

acronix — Tue, 31 Aug 2010 15:25:00 GMT

//考察点: 纯模拟
//思路: 大概听别人说过解题的方向
//提交情况: 2WA 1AC
第一次错在两个case之间没有空格(实际上应该有)
第二次错在最后一个case多了一个回车(实际上应该没有)
//收获: 对枚举更加熟悉了
//经验: 写完代码仍然需要静态观察纠结很久的代码需要静下心来一个个模块严重
//ACcode:

//终于AC  啊啊啊啊啊啊
#include<stdio.h>
#include<string.h>
#include<memory.h>
char a[5][30] = {
{'#','-','#','#',' ','#','#','-','#','#','-','#','#',' ','#','#','-','#','#','-','#','#','-','#','#','-','#','#','-','#'},
{'|',' ','|','#',' ','|','#',' ','|','#',' ','|','|',' ','|','|',' ','#','|',' ','#','#',' ','|','|',' ','|','|',' ','|'},
{'#',' ','#','#',' ','#','#','-','#','#','-','#','#','-','#','#','-','#','#','-','#','#',' ','#','#','-','#','#','-','#'},
{'|',' ','|','#',' ','|','|',' ','#','#',' ','|','#',' ','|','#',' ','|','|',' ','|','#',' ','|','|',' ','|','#',' ','|'},
{'#','-','#','#',' ','#','#','-','#','#','-','#','#',' ','#','#','-','#','#','-','#','#',' ','#','#','-','#','#','-','#'}};

void output(int size,char t[])
{
    int cnt,i,j,k,tt,mark,len=strlen(t),n=0;
    char *p = t;
    while(*p)
    {
        *p -= '0';
        p++;
    }
    for(i=0;i<5;i++)
    {
        if(i%2 == 0) //even
        {
            for(cnt=3*t[n];n<len;cnt=3*t[++n])
            {
                for(j=cnt,mark = cnt;j<cnt+3;j++)
                {
                    if(a[i][j] == '#') printf(" ");
                    else for(k=0;k<size;k++) printf("%c",a[i][j]);
                    if(j == mark+2 && n != len-1) printf(" ");
                }
            }
            n=0;
            printf("\n");
        }
        else //odd
        {
            for(tt=0;tt<size;++tt)
            {
                for(cnt=3*t[n];n<len;cnt=3*t[++n])
                {
                    for(j=cnt,mark=cnt;j<cnt+3;j++)
                    {

                        if(a[i][j] == '#') printf(" ");
                        else if(a[i][j] == '|') {printf("|");}
                        else for(k=0;k<size;k++) printf("%c",a[i][j]);
                        if(j == mark+2 && n != len-1) printf(" ");
                    }
                }
                n=0;
                printf("\n");
            }
        }
    }
}

int main()
{
    int n;
    char tmp[11];
    while(1)
    {

        scanf("%d %s",&n,tmp);
        if(n == 0 && !strcmp(tmp,"0")) break;
        output(n,tmp);
        printf("\n");
        memset(tmp,0,sizeof(tmp));
    }
    return 0;
}

acronix 2010-08-31 23:25 发表评论

pku_3096

acronix — Fri, 27 Aug 2010 07:39:00 GMT

//special thanks to : http://hi.baidu.com/elliott_hdu/blog/item/9841f0a8c8b004b4cb130cf3.html

//考察点: 字符串的处理

//思路: 要求判定题目中描述的 surprising string . 用到了一个类似枚举的方法按照题意直接模拟解决问题

//收获: 学习到了一种记忆以前状态的方法做成数组的方式来判定是不是在枚举的过程中曾经出现过.

//经验: 类似字符串处理的题目经常跟下标的确定有很大的关系, 往往数组的下标可以造成很大的差异并且枚举数据的时候边界也很不好确定. 这些都需要在写程序之前想好.

//ACcode:

#include<stdio.h>
#include<string.h>
#include<memory.h>
char a[80];
int rec[30][30];
bool judge()
{
    int len,i,j;
    len = strlen(a);
    if(len <= 2) return true;
    memset(rec,-1,sizeof(rec));
    for(i=0;i<=len-2;i++)                          //枚举从长度0一直到len-2  这是根据题目的意思     联系KMP算法  第一层的时候也是枚举长度
        for(j=0;j<len-i-1;j++)                      //这里是总长度去掉枚举出的长度i 也就是 len-i-2(长度i的边界的两个数字(不包含在长度i中))+1 = len-i-1;
        {
            if(rec[a[j]-'A'][a[j+i+1]-'A'] == i) return false;
            else rec[a[j]-'A'][a[j+i+1]-'A'] = i;
        }
    return true;
}

int main()
{
    //freopen("pku_3096_in.txt","r",stdin);
    while(scanf("%s",a))
    {
        if(strcmp(a,"*")==0) break;

    if(judge())
        printf("%s is surprising.\n",a);
    else
        printf("%s is NOT surprising.\n",a);
    }
    return 0;
}

acronix 2010-08-27 15:39 发表评论

pku_1111

acronix — Thu, 26 Aug 2010 20:36:00 GMT

//考察点: 简单dfs
//思路: 这个题目可以用dfs做也可用bfs做但是bfs还没有想到怎么做. 在dfs的过程中就能顺便计算出周长(perimeter) 像类似这样的题目非常像走迷宫类型. 因为需要求解的是最终的周长发现一个性质如果某个X跟其他的X相邻的话,相邻处就要扣掉一条边(初始perimeter is 4) 于是利用深搜找到所有的可能.
//提交情况 3WA 2AC
WA 因为技术变量 i,j 位置没有放对最好不要开成全局的否则会出现莫名其妙的错误.
//收获: 第一次接触dfs. 知道dfs是利用递归的思路来做的只要子问题跟原问题的性质相同递归就能发挥作用.
//经验: 写递归程序的时候可以把之后的问题看成是子问题于是处理好程序出口以后就可以直接调用自己了.
//AC code

#include<stdio.h>
#include<memory.h>
#define maxn 21
char a[maxn][maxn];
bool c[maxn][maxn];
int e[8][2]={{-1,1},{0,1},{1,1},{-1,0},{1,0},{-1,-1},{0,-1},{1,-1}};
int f[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
int sum;
int n,m,p,q;
void dfs(int p1,int q1)
{
    int i,j;
    for(i=0;i<8;i++)
    {
        int pp = p1 + e[i][0];
        int qq = q1 + e[i][1];
        if(pp<0||pp>=n||qq<0||qq>=m) continue;
        if(a[pp][qq] == '.') continue;
        if(c[pp][qq] == 1) continue;
        for(j=0;j<4;j++)
        {
            int x = pp + f[j][0];
            int y = qq + f[j][1];
            if(x<0||x>=n||y<0||y>=m) {sum++;continue;}
            if(c[x][y] == true)
            {
                sum--;
                continue;
            }
            else
            {
                sum++;
                continue;
            }
        }
        c[pp][qq] = true;
        dfs(pp,qq);
    }
}

int main()
{
    int i;
    //freopen("pku_1111_in.txt","r",stdin);
    while(1)
    {
        scanf("%d%d%d%d",&n,&m,&p,&q);
        if(n+m+p+q == 0) break;
        for(i=0;i<n;i++)
           scanf("%s",a[i]);
        p-=1,q-=1;
        if(a[p][q] == '.') {printf("0\n");continue;}
        memset(c,0,sizeof(c));
        sum = 4;
        c[p][q] = true;
        dfs(p,q);
        printf("%d\n",sum);
    }
    return 0;
}

acronix 2010-08-27 04:36 发表评论

pku_1125(参考了 cdy20)

acronix — Thu, 26 Aug 2010 20:01:00 GMT

/*
     Sourse: http://cdy20.bokee.com/viewdiary.41014871.html
  Name: Floyd-Warshall poj 1125
  Copyright: cdy20
  Author: cdy20
  Date: 29-07-08 16:38
  Description: Floyd-Warshall 复杂度O(n^3)
   本题目求那个中转者发信息给其他所有人的时间最快
   特别注意：一个人发信息给其他人，最快完成这项工作所需的时间
             由时间花费最长那个决定
  总结：floyd其实都是根据那两个定理变化，虽然那两个定理比较傻b
  （一看就知道，刚开始还奇怪，一看就知道的定理有什么用，
  现在发现，sb的一看就知道的定理可以变化成一个算法，几个定理解决一个问题）

  定理（大概）：
                1.任何两点i,j之间的路径若通过第三个点v,
                则此时i,v之间,v,j之间所连路径也是最短的.
                a[i][j]最短-->a[i][v],a[v][j]最短  (v为最短路径i-j经过的点)

                2.若i,j之间的路径比i,v之间,v,j之间路径的和大则i,j之间最短路径不大于i,v之间,
                v,j之间路径的和.
                 a[i][j]=min(a[i][j],a[i][k] a[k][j]);（这是在程序过程中，不断更新的）

*/

//考察点: floyd
//思路: 利用floyd求出任意两点之间的最短时间(存放在数组a[i][j]中) 找出a[i][j]中的最大值就是通知所有人所需要的最短时间(a[i][j]中的某一个值代表通知某人需要的最短时间,因此任意两个人之间通知的最短时间已知找到所有最短时间的最大值就是信息散布给所有人时的最坏情况也就是说当整个网络中最慢被通知到的人都被通知到了,有理由相信所有人都可以在这个时间内被通知到) 于是先用floyd求出任意两点之间的长度然后找到最大值如果找不到就输出 disjoint
//提交情况: 1AC
主要是在设置maxint的时候出错了原来(错误的状态是): const int INF = 1 << 30; 正确的设置方法应该是 const int INF = 0xfffffff;
//收获: 应用了一次floyd算法初步熟悉了该算法学会了怎么找到最小学会了怎样写 "没有找到希望的值"
//经验: 写好代码以后要观察时刻注意变量是不是需要初始化
//AC code

#include<stdio.h>
#include<memory.h>
#include<iostream>
#define MAX 101
using namespace std;
const int INF = 0xfffffff;
int a[101][101];

int main()
{
    int n,m,i,j,k;
    int tmp,val;

    while(1)
        {
            for(i=1;i<=100;i++)
                           for(j=1;j<=100;j++)
                                              a[i][j] = INF;
            scanf("%d",&n);
            if(n == 0) break;
            for(i=1;i<=n;i++)
            {
                             a[i][i] = 0;
                             scanf("%d",&m);
                             for(j=0;j<m;j++)
                             {
                                              scanf("%d%d",&tmp,&val);
                                              a[i][tmp] = val;
                             }
            }

            for(k=1;k<=n;k++)
                             for(i=1;i<=n;i++)
                                              for(j=1;j<=n;j++)
                                              {
                                                   a[i][j] = min(a[i][j],a[i][k]+a[k][j]);
                                              }
            val = -1;
            int ans = INF;
            for(i=1;i<=n;i++)
            {
                             tmp = -1;
                             for(j=1;j<=n;j++)
                             {
                                      tmp = max(tmp,a[i][j]);
                             }
                             if(tmp < ans) {ans = tmp;val = i;}
            }
            if(val == -1) printf("disjoint\n");
            else printf("%d %d\n",val,ans);
    }
    return 0;
}

acronix 2010-08-27 04:01 发表评论

hdu_3478

acronix — Thu, 19 Aug 2010 15:19:00 GMT

//考察点: 着色原理 BFS 邻接表建图
//思路: 先BFS,在BFS的过程中标记到达某点时的步数的奇偶性.
//提交情况: 3WA 1AC
第一次WA是因为判断是否相连的时候就错了后来的两次WA是因为没有初始化VIS数组,这个是我的老毛病了要更正!
//收获: 学习到了用邻接表建图的皮毛熟悉了用邻接表去建一个图的方法
//经验: 写好代码以后一定要想象一下处理每个CASE都用到了哪些东西用完之后都要想是不是需要初始化.!!!!很重要的一个习惯. 要养成这种好的编程习惯.
// ACcode

#include<memory.h>
#include<stdio.h>
#include<stdlib.h>
#define VN 100000
#define EN 500000
struct node
{
    int v;
    int nxt;
};

node mem[VN+EN+10];
int head[VN+1];
int cnt = 1;
int n,m,s;
int mark[VN];

void addedge(int u, int v)
{
    mem[cnt].v = v;
    mem[cnt].nxt = head[u];
    head[u] = cnt++;
}

int que[2*VN];
bool vis[VN];
int fore,tail;
bool bfs()
{
    bool flag = false;
    int i,j,count[VN]= {0};
    fore = tail = 0;
    que[tail ++] = s;
    vis[s] = true;
    count[s] = 0;
    mark[s] = 0;
    while(fore < tail)
    {
        j = que[fore ++];
        int p = head[j];
        while(p != 0)
        {
            i = mem[p].v;
            {
                if(!vis[i])
                {
                    vis[i] = true;
                    count[i] = count[j] + 1;
                    mark[i] = count[i] % 2;
                    que[tail ++] = i;
                }
                else if(vis[i])
                {
                    if(mark[i] == mark[j]) flag = true;
                }
            }
            p = mem[p].nxt;
        }
    }
    return flag;
}

int main()
{
    int T,i,j,k,t,p;
    int u,v;
    memset(mark,-1,sizeof(mark));
    scanf("%d",&T);
    for(i = 1; i <= T; i ++)
    {
        scanf("%d%d%d",&n,&m,&s);
        for(j = 0; j < m; j++)
        {
            scanf("%d%d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }

        bool s1,s2;
        s1 = bfs();
        s2 = true;
        for(int k = 0; k < n; k++)
        {
            if(vis[k] == false) {s2 = false;break;}
        }

        printf("Case %d: ",i);
        if(s1 && s2) printf("YES\n");
        else printf("NO\n");

        memset(head,0,sizeof(head));
        memset(mem,0,sizeof(mem));
        memset(mark,-1,sizeof(mark));
        memset(vis,0,sizeof(vis));
        cnt = 1;
    }
    return 0;
}

acronix 2010-08-19 23:19 发表评论

为自己将来的解题报告做一个规定

acronix — Thu, 19 Aug 2010 15:11:00 GMT

因为最近翻看之前的日志时发现之前的大约3篇关于程序的文章由于没有留下题目的任何信息而丧失了任何参考意义。因此必须要建立一个规范好让自己的总结起到应有的作用。

1.一定要留下题目的标号，最好是直接把题目粘贴过来。

2.按照以下的格式进行总结。

POJ1000.cpp

//考查点：会不会编程序。

//思路：此题要求输入两个数，输出两个数的和，我用 scanf 和 printf。

//提交情况：Wrong Answer 1次，忘了写 printf()。

Compile Error 2次，选错了语言，由于C++ 和 G++ 在 iostream.h 的不用引用方法；少一个大括号。

Accepted 1次。

//收获：学到了 scanf, printf 的基本用法，熟悉了 OJ 的系统环境。

//经验：写好代码后本地编译而且需要静态观察，杜绝编译错误。

// AC Code

#include

int main() {

int a,b;

scanf("%d%d",&a,&b);

printf("%d\n",a+b);

return 0;

}

暂时先这样子规定，以后在实践中不断完善。

acronix 2010-08-19 23:11 发表评论

hdu_3492 Segment

acronix — Tue, 17 Aug 2010 14:23:00 GMT

//考点: 计算几何

//思路:多个线段的投影有公共点 <=> 存在这样一条直线,该直线穿过所有的线段.

思考发现,满足条件的直线可以 <=> 给定2*n个线段端点中的某两个端点所确定的直线.

换句话说,如果存在穿过所有线段的直线X,那么X"旋转"之后会被某两个线段的端点"卡住".

只要证明：任何一条跟所有线段相交的直线都可以转化成所有端点中某两个端点的情况。

于是枚举任意两个端点，然后判断直线相交。

//提交情况: 6WA 2AC

主要WA在没有考虑到非常特殊的情况:所有的线段都是同一个点比如给了 5个线段所有的端点都是1.0000

//经验: 如果存储的时候把起点和终点存在相邻的两格中枚举的时候就好做多了另外issame的用法也比较巧(谢谢zhaozhouyang学长的无私帮助)

//收获: 枚举端点写的灰常的纠结啊... const doubel eps = 1e-8

//AC code

#include<stdlib.h>
#include <math.h>
#include<stdio.h>
#include <algorithm>
using namespace std;
#define maxN 300

const double eps = 1e-8;

/*double max(double a, double b)
{
    if(a>b) return a;
    else return b;
}

double min(double a, double b)
{
    if(a    else return b;
}*/

typedef struct
{
    double x,y;
}point;
point l[maxN*2];

double direction(point p1,point p2, point p3)
{//向量p1p3和向量p2p3的叉积 p3相对p1p2的转向
    return (p3.x-p1.x)*(p2.y-p1.y)-(p2.x-p1.x)*(p3.y-p1.y);
}
bool online(point p1,point p2,point p3)
{
    return (min(p1.x,p2.x)<=p3.x&&p3.x<=max(p1.x,p2.x))&&(min(p1.y,p2.y)<=p3.y&&p3.y<=max(p1.y,p2.y));
}

bool insect(point p1,point p2,point p3,point p4)
{
    //double d1=direction(p3,p4,p1);
   // double d2=direction(p3,p4,p2);
    double d3=direction(p1,p2,p3);
    double d4=direction(p1,p2,p4);
    if(d3*d4<0)
        return true;
   // else if(d1==0&&online(p3,p4,p1)) return true;
   // else if(d2==0&&online(p3,p4,p2)) return true;
    else if(d3==0) return true;
    else if(d4==0) return true;
    return false ;
}

int main()
{
    //freopen("segment.in","r",stdin);
   // freopen("segment.out","w",stdout);
    int cnt = 0;
    int N,n,i,j,k;
    bool flag;
    scanf("%d",&N);
    while(N--)
    {
        cnt ++;
        scanf("%d",&n);
        for(i=0;i<2*n-1;i+=2)
        {
            scanf("%lf%lf%lf%lf",&l[i].x,&l[i].y,&l[i+1].x,&l[i+1].y);
        }
       /* if (N == 39)
        {
            for(i=0;i<2*n-1;i+=2)
        {
            printf("%.0lf %.0lf,%.0lf %.0lf\n",l[i].x,l[i].y,l[i+1].x,l[i+1].y);
        }
        system("pause");

        }*/
        bool issame = true;
        flag = false;
        for(i=0;i< 2*n -1 && flag==false;i++)
            for(j=i+1;j < 2*n && flag==false;j++)
                {
                    if (fabs(l[i].x-l[j].x) <= eps && fabs(l[i].y-l[j].y) <= eps)
                    //if (l[i].x == l[j].x && l[i].y == l[j].y)
                        continue;
                    issame = false;
                    flag=true;
                    for(k=0;k<2*n-1;k+=2)
                    {
                        if(insect(l[i],l[j],l[k],l[k+1]) == false)
                         {flag=false;
                           break;}
                    }

                }
        if(flag==true || issame)
            {printf("Yes\n");}
        else printf("No\n");
    }
   // printf("%d\n",cnt);

    return 0;
}

acronix 2010-08-17 22:23 发表评论

hdu_3491感谢c j同学的帮助

acronix — Sun, 15 Aug 2010 12:50:00 GMT

//考察点: 拆点 + 最大流

//思路: 把城市作为点拆开(把城市i拆成cap数组中的cap[i][i+n].其中i作为城市i的入,i+n作为城市i的出),原来的街道仍然作为边,但是边权是无穷大. 只要注意到BFS的时候起点/终点是不需要拆的.(在cap[][]数组中就直接把起点/终点的入和出之间的边权赋值为0,使得BFS的时候不走起点/终点,实际上就相当于没有把起点/终点拆开.程序中的处理方法就是 cap[s][s+n] = 0;/cap[e][e+n] = 0;)

//提交情况; Wrong Answer 4次 Accepted 1次

WA 的原因是: BFS写错做完一个CASE没有初始化cap数组导致错误

//收获: 对BFS有了更深的理解对抽象出来的算法过程也有了具体的体会吸取了不初始化的教训

//经验: 在学习一个代码的时候要手动模拟一下过程好好理解算法的精髓另外要加强联系争取掌握用邻接表建图的方法

//ACcode

#include<stdio.h>
#include<memory.h>
#include<stdlib.h>
const int INF = 0x7fffffff;
int cap[201][201];
int s,t;
int que[201],pre[201];
int n,m;
bool vis[201];
bool findroad()
{
    memset(vis,0,sizeof(vis));
    int i,j;
    int head = 0,tail = 0;
    que[tail ++] = s;
    while(head < tail)
    {
        j = que[head ++];
        for(i = 1; i <= 2*n ;i ++)
        {
            if(!vis[i] && cap[j][i] > 0)
            {
                vis[i] = true;
                pre[i] = j;
                if(i == t) return true;
                que[tail ++] = i;
            }
        }
    }
    return false;
}
int maxflow()
{
    int flow = 0,i,min;
    while(findroad())
    {
        min = INF;
        for(i = t; i != s;i = pre[i])
        {
            if(cap[pre[i]][i] < min)
                    min = cap[pre[i]][i];
        }
        flow += min;
        for(i = t; i != s;i = pre[i])
        {
            cap[pre[i]][i] -= min;
            cap[i][pre[i]] += min;
        }
    }
    return flow;
}
int main()
{
    int T,x,y,i,j,tem,b,e;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d%d%d",&n,&m,&b,&e);
        for(i = 1; i <= n;i ++)
        {
            scanf("%d",&tem);
            cap[i][i+n] = tem;
        }
        s = b + n;
        t = e;
       cap[e][e+n]=0;
        cap[s][s+n]=0;
        for(i = 1; i <= m;i ++)
        {
            scanf("%d%d",&x,&y);
            cap[x+n][y] = INF;
            cap[y+n][x] = INF;
        }
        printf("%d\n",maxflow());
        memset(cap,0,sizeof(cap));
    }
    return 0;
}

acronix 2010-08-15 20:50 发表评论