5.1.3 Segment set

Segment set

Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 120 Accepted Submission(s): 54

Problem Description

A segment and all segments which are connected with it compose a segment set. The size of a segment set is the number of segments in it. The problem is to find the size of some segment set.

 

Input

In the first line there is an integer t - the number of test case. For each test case in first line there is an integer n (n<=1000) - the number of commands.

There are two different commands described in different format shown below:

P x1 y1 x2 y2 - paint a segment whose coordinates of the two endpoints are (x1,y1),(x2,y2).
Q k - query the size of the segment set which contains the k-th segment.

k is between 1 and the number of segments in the moment. There is no segment in the plane at first, so the first command is always a P-command.

 

Output

            For each Q-command, output the answer. There is a blank line between test cases.

 

Sample Input

1
10
P 1.00 1.00 4.00 2.00
P 1.00 -2.00 8.00 4.00
Q 1
P 2.00 3.00 3.00 1.00
Q 1
Q 3
P 1.00 4.00 8.00 2.00
Q 2
P 3.00 3.00 6.00 -2.00
Q 5

 

Sample Output

1
2
2
2
5

 

Author

LL

思路：就是判断当前线段与以前的线段是否相交且是否为同一集合，并查集很简单，就是计算几何我还不懂，网上找了个写的不错的贴出来（他考虑到了浮点误差！！）

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;

const double eps = 1e-12;
const int size = 1000;

struct point
{
    double x, y;
};

struct seg
{
    point a, b;
} S[size + 20];

double multi (  point p1, point p2,point p0)
{
    return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
}

bool isIntersected(point s1, point e1, point s2, point e2)
{
    if(
        (max(s1.x, e1.x) >= min(s2.x, e2.x)) &&
        (max(s2.x, e2.x) >= min(s1.x, e1.x)) &&
        (max(s1.y, e1.y) >= min(s2.y, e2.y)) &&
        (max(s2.y, e2.y) >= min(s1.y, e1.y)) &&
        (multi(s2, e1, s1) * multi(e1, e2, s1) >= -eps) &&
        (multi(s1, e2, s2) * multi(e2, e1, s2) >= -eps)
    )  return true;

    return false;
}

int father[size + 10], n, rank[size + 10];


int Find_Set(int x)
{
    if (x != father[x])
    {
        father[x] = Find_Set(father[x]);
    }
    return father[x];
}

void Union(int x, int y)
{
    x = Find_Set(x);
    y = Find_Set(y);
    if (x != y)
    {
        father[x] = y;
    }
}

int main()
{
    int  t;
    char ST[2];
    scanf("%d", &t);
    int tt = t;
    while (t --)
    {
        if (t != tt - 1)printf("\n");
        scanf("%d", &n);
        int j = 0;
        for (int i = 0; i < n; i ++)
        {
            scanf("%s", ST);
            if (ST[0] == 'P')
            {
                scanf("%lf%lf%lf%lf", &S[j].a.x, &S[j].a.y, &S[j].b.x, &S[j].b.y);
                father[j] = j;
                for (int k = 0; k < j; k ++)
                {
                    if (isIntersected(S[j].a, S[j].b, S[k].a, S[k].b))
                    {
                        Union (j, k);
                    }
                }
                j ++;
            }
            else if (ST[0] == 'Q')
            {
                int s, sum = 0;
                scanf("%d", &s);
                for (int k = 0; k < j; k ++)
                    if (Find_Set(s - 1) == Find_Set(k))sum ++;
                printf("%d\n", sum);
            }
        }

    }
    return 0;
}