有N个坐标，求能构成正方形的数量（dfs）

  深度优先算法还不是太熟练，判断四个点坐标能否构成正方形还是需要一定的思考。

  写了个测试case，应该问题不大。

package com;


import java.util.*;

public class Main {
    static int c = 0;

    public static class Pos {
        int x;
        int y;

        public Pos(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "Pos{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    public static void main(String[] args) {

        boolean flag[] = new boolean[6];
        Pos[] pos = new Pos[6];
        pos[0] = new Pos(0, 1);
        pos[1] = new Pos(0, 0);
        pos[2] = new Pos(-1, 0);
        pos[3] = new Pos(-1, 1);
        pos[4] = new Pos(1, 1);
        pos[5] = new Pos(1, 0);

        dfs(flag, pos, new Stack<Pos>(), 0);
        System.out.println(c);


    }

    //获取不同坐标集（4个坐标构成一个坐标集）
    public static void dfs(boolean flag[], Pos[] pos, Stack<Pos> stack, int j) {
        if (stack.size() == 4) {
            if (valid(stack)) c++;
            return;
        }
        for (int i = 0; i < pos.length; i++) {
            //确保不向上递归
            if (i < j) continue;
            //剪枝法
            if (flag[i]) continue;
            stack.push(pos[i]);
            flag[i] = true;
            dfs(flag, pos, stack, i);
            flag[i] = false;
            stack.pop();
        }
    }

    //判断四个点是否能构成正方形
    public static boolean valid(Stack<Pos> pos) {
        int num = 0;
        Stack<Pos> p = new Stack<>();
        p.addAll(pos);
        Pos jz = p.pop();
        p.remove(jz);
        int[] len = new int[3];
        int j = 0;
        int n = 0;
        //获取一个点到另外三个点的距离，如果四个点能构成正方形，则必有两条领边和对角线
        while (p.size() != 0) {
            Pos k = p.pop();
            len[j] = (jz.x - k.x) * (jz.x - k.x) + (jz.y - k.y) * (jz.y - k.y);
            j++;
        }
        //判断如果有两条领边及其两条领边的对角线能够构成等腰直角三角形则为正方形
        if (len[0] + len[1] == len[2] && len[0] == len[1] || len[1] + len[2] == len[0] && len[1] == len[2] || len[2] + len[0] == len[1] && len[2] == len[0]) {
            n++;
        }
        if (n == 1) return true;
        return false;
    }
}