Parallel Lines Aizu - 1379(暴力)

题目大意：

给出几个点的坐标
只可以两两点相连，一个点最多连一个点
问最多可以连多少组平行线，在一个图中

思路

枚举两两点的连接组合，构建向量，dfs, 当每个点都用上了后，在枚举两两向量计算出平行的组数，最后的答案就是取最大的值。

代码

/**
* 　　　┏┓　　　┏┓
* 　　┏┛┻━━━┛┻┓
* 　　┃　　　　　　　 ┃
* 　　┃　　　━　　　 ┃
* 　　┃　┳┛　┗┳　┃
* 　　┃　　　　　　　 ┃
* 　　┃　　　┻　　　 ┃
* 　　┃　　　　　　　 ┃
* 　　┗━┓　　　┏━┛Codes are far away from bugs with the animal protecting
* 　　　　┃　　　┃    神兽保佑,代码无bug
* 　　　　┃　　　┃
* 　　　　┃　　　┗━━━┓
* 　　　　┃　　　　　 ┣┓
* 　　　　┃　　　　 ┏┛
* 　　　　┗┓┓┏━┳┓┏┛
* 　　　　　┃┫┫　┃┫┫
* 　　　　　┗┻┛　┗┻┛
**/

#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
struct Node
{
    int x, y;
    Node(int x=0, int y=0): x(x), y(y) {}
} pt[maxn];

Node vec[maxn*maxn];
int n;
int vis[maxn];
int ins;
int sum;

void dfs(int u)
{
    while(u<n&&vis[u]) u++;                                                                      
    if(u==n) {
        int thisum=0;
        for(int i=0;i<ins;i++){
            for(int j=i+1;j<ins;j++) {
                if(vec[i].x*vec[j].y==vec[i].y*vec[j].x) {
                    thisum++;
                }
            }
        }
        sum=max(thisum, sum);
        return ;
    }
    vis[u]=1;
    for(int i=u;i<n;i++) {
        if(!vis[i]) {
            vis[i]=1;
            vec[ins++]=Node(pt[i].x-pt[u].x,pt[i].y-pt[u].y);
            dfs(u+1);
            ins--;
            vis[i]=0;
        }
    }
    vis[u]=0;
}

int main()
{
    //freopen("input.txt", "r", stdin);
    while(~scanf("%d", &n)) {
        for(int i=0;i<n;i++) {
            scanf("%d%d", &pt[i].x, &pt[i].y);
        }
        ins=0;
        sum=0;
        memset(vis, 0, sizeof(vis));
        dfs(0);
        cout << sum << endl;
    }
    return 0;
}

总结

比赛时，写了一份自以为很ac的代码，超时了，事实上16个坐标跟本跑不出来。当时我是这么做的，先把所有向量枚举出来这大约就有n(n-1)/2个了，然后对这么多向量枚举找n/2个向量，不超时就怪了。
TL代码

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <list>
#include <cstdlib>
#include <memory>
#include <cstring>
#include <sstream>
#include <list>
#include <deque>
#include <bitset>
#include <vector>

using namespace std;

#define INF 0x3f3f3f3f
#define PI 3.141592653579
#define FRER() freopen("input.txt" , "r" , stdin);
#define FREW()  freopen("output.txt" , "w" , stdout);
#define  QIO std::ios::sync_with_stdio(false)
#define mem(a , b) memset(a , b , sizeof(a))
const double eps = 1e-8;
typedef long long ll;
const int maxn = 30;
int cnt, n;
ll ans;

struct Point
{
    int x, y;
    int cur;
}point[maxn];

struct Vec
{
    Point p[2]; //起始点和终点
    int hav;
} vec[maxn*maxn];

int gcd(int a, int b)
{
    return b==0?a:gcd(b, a%b);
}

int _hash(Point a, Point b)
{
    int x=a.x-b.x;
    int y=a.y-b.y;
    if(x<0) {
        x = -x;
        y = -y;
    }
    int gc=gcd(abs(x), abs(y));
    x=x/gc;
    y=y/gc+2000;
    return x * 10000 + y;
}

map<int, int> m;
bool vis[maxn*maxn];
bool visp[maxn];
set<int> st;   // 在一个集合的所有点的idx

void dfs(int cur)
{
    if(cur==n/2) {
        ll sum=0;
        for(map<int, int>::iterator it = m.begin(); it != m.end(); it++)
        {
            sum+=(it->second)*(it->second-1)/2;
        }
        ans=max(ans, sum);
        return;
    }
    for(int i=0; i<cnt;i++)
    {
        if(!vis[i]&&!visp[vec[i].p[0].cur]&&!visp[vec[i].p[1].cur]) {
            vis[i]=true;
            visp[vec[i].p[0].cur]=true;
            visp[vec[i].p[1].cur] = true;
            m[vec[i].hav]++;
            dfs(cur+1);
            visp[vec[i].p[0].cur]=false;
            visp[vec[i].p[1].cur] =false;
            m[vec[i].hav]--;
            vis[i]=false;
        }
    }
}

int main()
{
    //FRER();
    scanf("%d" , &n);
    for(int i = 0 ; i < n ; i++)
    {
        scanf("%d%d", &point[i].x, &point[i].y);
        point[i].cur=i;
    }
    cnt=0;
    for(int i = 0 ; i < n ; i++)
    {
        for(int j = i+1 ; j < n ; j++)
        {
                vec[cnt].hav = _hash(point[i], point[j]);
                vec[cnt].p[0] = point[i];
                vec[cnt].p[1] = point[j];
                cnt++;
        }
    }
    ans=-134566;
    memset(vis, false, sizeof(vis));
    memset(visp, false, sizeof(visp));
    dfs(0);
    cout << ans << endl;
    return 0;
}