LeetCode Contest--20190224

问题一：https://leetcode.com/problems/find-the-town-judge/

十分有趣的问题，就是一个图的矩阵表示问题

class Solution {
    public int findJudge(int N, int[][] trust) {
        
        int[][] adj=new int[N][N];
        
        for(int i=0;i<trust.length;i++)
        {
            adj[ trust[i][0]-1 ][ trust[i][1]-1 ]=1;
        }
        
        for(int i=0;i<N;i++)
        {
            int count1=0,count2=0;
            for(int j=0;j<N;j++)
            {
                count1 += adj[j][i];
                count2 += adj[i][j];
            }
                
            if(count1==N-1  && count2==0)
                return i+1;
        }
        return -1;
    }
}

问题二：https://leetcode.com/problems/available-captures-for-rook/

这个问题解的也比较暴力

class Solution {
    public int numRookCaptures(char[][] board) {
        int east=0,west=0,south=0,north=0;
        int startRow=-1,startCol=-1;
        for(int i=0;i<board.length;i++)
        {
            for(int j=0;j<board[0].length;j++)
            {
                if(board[i][j]=='R')
                {
                    startRow=i;
                    startCol=j;
                    break;
                }
            }
        }
        
        for(int i=startCol+1;i<board[0].length;i++)
        {
            if(board[startRow][i]=='B')
                break;
            else if(board[startRow][i]=='p')
            {
                east++;
                break;
            }
        }
        
        for(int i=startCol-1;i>=0;i--)
        {
            if(board[startRow][i]=='B')
                break;
            else if(board[startRow][i]=='p')
            {
                west++;
                break;
            }
        }
        
        for(int i=startRow+1;i<board.length;i++)
        {
            if(board[i][startCol]=='B')
                break;
            else if(board[i][startCol]=='p')
            {
                south++;
                break;
            }
        }
        
        for(int i=startRow-1;i>=0;i--)
        {
            if(board[i][startCol]=='B')
                break;
            else if(board[i][startCol]=='p')
            {
                north++;
                break;
            }
        }
        return east+west+south+north;
    }
}

问题三：https://blog.csdn.net/To_be_to_thought/article/details/87918091

问题四：https://leetcode.com/problems/grid-illumination/

hard级别的问题，我想了一个比较有趣但是空间复杂度较高的算法，借鉴的是N 皇后的思想方法对每一个行、列、对角线进行编码，再对格点坐标进行映射编码。应为使用了许多hash数据结构HashMap、HashSet嵌套，空间复杂度较高，但是时间复杂度很低。这个代码debug了好久才AC的。

class Solution {
    /*
    N*N格网分别有N（编号0-N-1）个行，N（0-N-1）个列，2*N-1（0-2*N-2）个主对角线，2N-1（0-2N-2）个
    副对角线，它们的编号分别存在mapRow，mapCol，mapDig，mapAss上，映射的是格点坐标编码后的数
    字(i,j)编码为code=i*N+j(0<=j<N),code转为坐标为（code/N,code%N）
    */

    public static HashMap<Integer,HashSet<Integer>> mapRow;

    public static HashMap<Integer,HashSet<Integer>> mapCol;

    public static HashMap<Integer,HashSet<Integer>> mapDig;

    public static HashMap<Integer,HashSet<Integer>> mapAss;

    public static HashSet<Integer> lampPoints;

    public static int[] gridIllumination(int N, int[][] lamps, int[][] queries) {

        int[] ret=new int[queries.length];

        mapRow=new HashMap<>();
        mapCol=new HashMap<>();
        mapDig=new HashMap<>();
        mapAss=new HashMap<>();
        lampPoints=new HashSet<>();

        int r,c,m,a,code;

        for(int i=0;i<lamps.length;i++)
        {
            r=lamps[i][0];
            c=lamps[i][1];
            m=N-1-lamps[i][0]+lamps[i][1];
            a=lamps[i][0]+lamps[i][1];
            code=lamps[i][0]*N+lamps[i][1];
            lampPoints.add(code);

            if(mapRow.containsKey(r))
                mapRow.get(r).add(code);
            else
            {
                mapRow.put(r,new HashSet<>());
                mapRow.get(r).add(code);
            }

            if(mapCol.containsKey(c))
                mapCol.get(c).add(code);
            else
            {
                mapCol.put(c,new HashSet<>());
                mapCol.get(c).add(code);
            }


            if(mapDig.containsKey(m))
                mapDig.get(m).add(code);
            else
            {
                mapDig.put(m,new HashSet<>());
                mapDig.get(m).add(code);
            }


            if(mapAss.containsKey(a))
                mapAss.get(a).add(code);
            else
            {
                mapAss.put(a,new HashSet<>());
                mapAss.get(a).add(code);
            }

        }

        for(int i=0;i<queries.length;i++)
        {
            r=queries[i][0];
            c=queries[i][1];
            m=N-1-queries[i][0]+queries[i][1];
            a=queries[i][0]+queries[i][1];
            boolean flag=false;
            flag = flag || mapRow.containsKey(r) || mapCol.containsKey(c) || mapDig.containsKey(m) || mapAss.containsKey(a);
            if(flag)
            {
                ret[i]=1;
                closeSelfOrOneNeighbor(queries[i][0],queries[i][1],N);
            }
            else
                ret[i]=0;
        }
        return ret;

    }

    public static void closeSelfOrOneNeighbor(int i,int j,int N)
    {
        boolean flag=false;
        for(int dx=-1;dx<=1;dx++)
        {
            for(int dy=-1;dy<=1;dy++)
            {
                if(isValid(i+dx,j+dy,N))
                {
                    int r=i+dx;
                    int c=j+dy;
                    int m=N-1-i-dx+j+dy;
                    int a=i+dx+j+dy;
                    int code=(i+dx)*N+j+dy;
                    if(lampPoints.contains(code))
                    {
                        lampPoints.remove(code);
                        if(mapRow.containsKey(r))
                        {
                            mapRow.get(r).remove(code);
                            if(mapRow.get(r).isEmpty())
                                mapRow.remove(r);
                        }
                        if(mapCol.containsKey(c))
                        {
                            mapCol.get(c).remove(code);
                            if(mapCol.get(c).isEmpty())
                                mapCol.remove(c);
                        }
                        if(mapDig.containsKey(m))
                        {
                            mapDig.get(m).remove(code);
                            if(mapDig.get(m).isEmpty())
                                mapDig.remove(m);
                        }
                        if(mapAss.containsKey(a))
                        {
                            mapAss.get(a).remove(code);
                            if(mapAss.get(a).isEmpty())
                                mapAss.remove(a);
                        }
                        flag=true;
                        break;
                    }
                }
            }
            if(flag)
                break;
        }
    }

    public static boolean isValid(int i,int j,int N)
    {
        return i>=0 && i<N && j>=0 && j<N;
    }
    
}