• Run


    Run

    Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
    Total Submission(s): 1047    Accepted Submission(s): 459


    Problem Description
    AFA is a girl who like runing.Today,he download an app about runing .The app can record the trace of her runing.AFA will start runing in the park.There are many chairs in the park,and AFA will start his runing in a chair and end in this chair.Between two chairs,she running in a line.she want the the trace can be a regular triangle or a square or a regular pentagon or a regular hexagon.
    Please tell her how many ways can her find.
    Two ways are same if the set of chair that they contains are same.
     
    Input
    There are multiply case.
    In each case,there is a integer n(1 < = n < = 20)in a line.
    In next n lines,there are two integers xi,yi(0 < = xi,yi < 9) in each line.
     
    Output
    Output the number of ways.
     
    Sample Input
    4
    0 0
    0 1
    1 0
    1 1
     
    Sample Output
    1
     
    Source
     
     题意:给你n个整数点,判断从中任取某些点能否组成正多边形,有几种可能情况(整数点可能情况只能是正方形,
    #include<iostream>
    #include<algorithm>
    #include<cstdio>
    #include<cstring>
    
    using namespace std;
    
    #define N 25
    
    int n;
    
    struct node
    {
        int x, y;
    }P[N];
    
    int slove(int i, int j, int k, int q)
    {
        if(i == j || i == k)
            return false;
        if(i == q || j == k)
            return false;
        if(j == q || k == q)
            return false;
    
        int w = 0, num[8];
        memset(num, 0, sizeof(num));
    
        num[w++] = (P[i].x-P[j].x)*(P[i].x-P[j].x)+(P[i].y-P[j].y)*(P[i].y-P[j].y);
        num[w++] = (P[i].x-P[k].x)*(P[i].x-P[k].x)+(P[i].y-P[k].y)*(P[i].y-P[k].y);
        num[w++] = (P[i].x-P[q].x)*(P[i].x-P[q].x)+(P[i].y-P[q].y)*(P[i].y-P[q].y);
        num[w++] = (P[j].x-P[k].x)*(P[j].x-P[k].x)+(P[j].y-P[k].y)*(P[j].y-P[k].y);
        num[w++] = (P[j].x-P[q].x)*(P[j].x-P[q].x)+(P[j].y-P[q].y)*(P[j].y-P[q].y);
        num[w++] = (P[q].x-P[k].x)*(P[q].x-P[k].x)+(P[q].y-P[k].y)*(P[q].y-P[k].y);
    
        sort(num, num+w);
    
        w = unique(num, num+w) - num;
    
        if(w != 2)
            return false;
        return true;
    }
    
    int main()
    {
        while(scanf("%d", &n) != EOF)
        {
            int ans = 0;
    
            for(int i = 1; i <= n; i++)
                scanf("%d%d", &P[i].x, &P[i].y);
    
            for(int i = 1; i <= n; i++)
                for(int j = i+1; j <= n; j++)
                    for(int k = j+1; k <= n; k++)
                        for(int q = k+1; q <= n; q++)
                            if(slove(i, j, k, q))
                                ans++;
    
            printf("%d
    ", ans);
        }
        return 0;
    }
    

      

  • 相关阅读:
    概率论与统计学---笔记
    实用概率论与数理统计学--笔记
    并发编程总结5-JUC-REENTRANTLOCK-3(非公平锁)
    并发编程总结4-JUC-REENTRANTLOCK-2(公平锁)
    并发编程总结3——JUC-LOCK-1
    DOCKER & SWARM1.2
    Docker
    hdfs命令
    并发编程总结2——java线程基础2
    并发编程总结1——java线程基础1
  • 原文地址:https://www.cnblogs.com/Tinamei/p/4944897.html
Copyright © 2020-2023  润新知