zoukankan      html  css  js  c++  java
  • LeetCode 图

    DAG有向无环图 拓扑排序(207,208)

    拓扑排序判断有无环。判断是否是有向无环图

    方法1:DFS

    思路:(自己多在演草纸上想想,把所有演草纸收集起来!)

    题解:https://chenzhuo.blog.csdn.net/article/details/91127897

    class Solution {
    public:
        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
            vector<int> flag(numCourses,0);
            vector<vector<int>> tmp(numCourses);
            if(prerequisites.empty()) return true;
            for(int i=0;i<prerequisites.size();i++){
                tmp[prerequisites[i][0]].push_back(prerequisites[i][1]);
            }
            bool ans=true;
            for(int i=0;i<numCourses;i++){
                ans = ans&&DFS(i,flag,tmp);
            }
            return ans;
        }
        bool DFS(int i,vector<int> &flag,vector<vector<int>> &tmp){//注意要加上"&"
            if(flag[i]==-1){
                return false;
            }
            if(flag[i]==1){
                return true;
            }
            //第一次的入口:
            flag[i]=-1;
            for(int j=0;j<tmp[i].size();j++){
                if(DFS(tmp[i][j],flag,tmp)){
                    continue;
                }
                return false;
            }
            flag[i]=1;
            return true;
        }
    };

     解法2:

    方法二:根据入度判断
    课程先后顺序可以理解为一个有向图,有解的条件是此图无环。因此我们可以依据其先后顺序构造有向图,并统计每门课程的入度(即其前一门课程的数量)。

    然后将入度为0的所有课程压入栈中,然后将这些课程的下一门课程的入度减1,减完后入度为0则入栈。重复上述操作直到栈为空。 如果最后存在入度不为为0的节点就说明有环,无解。

    《算法笔记》也有这个算法

    class Solution {
    public:
        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
            vector<int> indegree(numCourses);
            vector<vector<int>>Graph(numCourses);
            queue<int> ZeroQ;
            vector<int> ans,empty;//结果数组
            int i,j,cnt=0;
            int start,end;
            //初始化邻接矩阵
            for(i=0;i<prerequisites.size();i++){
                start=prerequisites[i][0];
                end=prerequisites[i][1];
                Graph[end].push_back(start);
                indegree[start]++;
            }
            //初始化队列
            for(i=0;i<numCourses;i++){
                if(indegree[i]==0){
                    ZeroQ.push(i);
                }
            }
            while(!ZeroQ.empty()){
                int v=ZeroQ.front();
                ans.push_back(v);
                ZeroQ.pop();
                cnt++;
                for(j=0;j<Graph[v].size();j++){
                    int u=Graph[v][j];
                    indegree[u]--;
                    if(indegree[u]==0){
                        ZeroQ.push(u);
                    }
                }
            }
            if(cnt!=numCourses){
                return false;
            }
            return true;
            
        }
    };

    2019-09-28 09:44:28

    简化到不能再简

    class Solution {
    public:
        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
             vector<vector<int>> G(numCourses);
            vector<int> degree(numCourses, 0), bfs;
            for (auto& e : prerequisites)
                G[e[1]].push_back(e[0]), degree[e[0]]++;
            for (int i = 0; i < numCourses; ++i) if (!degree[i]) bfs.push_back(i);
            for (int i = 0; i < bfs.size(); ++i)
                for (int j: G[bfs[i]])
                    if (--degree[j] == 0) bfs.push_back(j);
            return bfs.size() == numCourses;
        }
    };

    第二天:

    class Solution {
    public:
        bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
            vector<vector<int>> graph(numCourses);
            vector<int> inDegree(numCourses,0);
            for(auto& edge : prerequisites){
                graph[edge[1]].push_back(edge[0]);
                ++inDegree[edge[0]];
            }
            vector<int> result;
            for(int i=0;i<numCourses;++i){
                if(inDegree[i]==0) result.push_back(i);
            }
            for(int i=0;i<result.size();++i){
                for(auto j : graph[result[i]]){
                    if(--inDegree[j]==0) result.push_back(j);
                }
            }
            return result.size()==numCourses;
        }
    };

     还是把自己想得太厉害了。然而自己并不能过目不忘。还是要多敲代码,多巩固,真的感觉到了如果能把自己做过的题保证大部分能做对,真的已经很厉害了。


    这个题的代码和上个题完全一样。只是输出换了。

    解法1:

    队列

    class Solution {
    public:
        vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
            vector<int> indegree(numCourses);
            vector<vector<int>>Graph(numCourses);
            queue<int> ZeroQ;
            vector<int> ans,empty;//结果数组
            if(numCourses==1){
                empty.push_back(0);
                return empty;
            }
            int i,j,cnt=0;
            int start,end;
            //初始化邻接矩阵
            for(i=0;i<prerequisites.size();i++){
                start=prerequisites[i][0];
                end=prerequisites[i][1];
                Graph[end].push_back(start);
                indegree[start]++;
            }
            //初始化队列
            for(i=0;i<numCourses;i++){
                if(indegree[i]==0){
                    ZeroQ.push(i);
                }
            }
            while(!ZeroQ.empty()){
                int v=ZeroQ.front();
                ans.push_back(v);
                ZeroQ.pop();
                cnt++;
                for(j=0;j<Graph[v].size();j++){
                    int u=Graph[v][j];
                    indegree[u]--;
                    if(indegree[u]==0){
                        ZeroQ.push(u);
                    }
                }
            }
            if(cnt!=numCourses){
                return empty;
            }
            return ans;
        }
    };

     简化版:

    2019-09-28

    10:32:15

    class Solution {
    public:
        vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
            vector<int> result;//最优答案
            vector<int> empty;//空数组
            queue<int> temp;//存储入度为0的节点
            if(numCourses==0){
                empty.push_back(0);
                return empty;
            }
            vector<vector<int>> graph(numCourses);
            vector<int> inDegree(numCourses,0);
            for(auto& edge : prerequisites){
                graph[edge[1]].push_back(edge[0]);
                inDegree[edge[0]]++;
            }
            for(int i=0;i<numCourses;++i){
                if(!inDegree[i]){
                    temp.push(i);
                }
            }
            int cnt=0;
            while(!temp.empty()){
                int pre = temp.front();result.push_back(pre);temp.pop();
                ++cnt;
                for(auto i : graph[pre]){
                    if(--inDegree[i]==0) temp.push(i);
                }
            }
            if(cnt!=numCourses) return empty;
            return result;
        }
    };

     2019-09-30

    09:21:49

     染色问题。

    看的评论:采用了贪心算法。

    class Solution {
    public:
        vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
            vector<vector<int>> result(N);
            vector<int> color(N,1);
            for(auto path : paths){
                result[max(path[0],path[1])-1].push_back(min(path[0],path[1])-1);
            }
            for(int i=1;i<N;++i){
                set<int> set_color{1,2,3,4};
                for(int j=0;j<result[i].size();++j){
                    set_color.erase(color[result[i][j]]);
                }
                color[i] = *set_color.begin();
            }
            return color;
        }
    };

    2019-10-04

    11:40:54

     

     解法1:Dijkstra算法

    class Solution {
    public:
        int networkDelayTime(vector<vector<int>>& times, int N, int K) {
            vector<vector<int>> v(N+1,vector<int>(N+1,-1));
            for(int i=0;i<times.size();i++){
                v[times[i][0]][times[i][1]]=times[i][2];
            }
            vector<int> S(N+1,-1),T(N+1,-1);
            for(int i=1;i<N+1;i++)
                T[i]=v[K][i];
            T[K]=0;
            int min_val=-1,min_idx=-1;
            for(int c=0;c<N;c++){
                //find min_val of T
                min_val=-1;
                for(int i=1;i<T.size();i++){
                    if(T[i]!=-1&&S[i]==-1){
                        if(min_val==-1||T[i]<min_val){
                            min_idx=i;
                            min_val=T[i];
                        }
                    }
                }
                S[min_idx]=min_val;
                //update
                for(int i=1;i<T.size();i++){
                    if(v[min_idx][i]!=-1&&(min_val+v[min_idx][i]<T[i]||T[i]==-1)){
                        T[i]=min_val+v[min_idx][i];
                    }  
                }
            }
            int res=-1;
            for(int i=1;i<S.size();i++){
                if(S[i]==-1)
                    return -1;
                res=max(res,S[i]);
            }   
            return res;
        }
    };

    解法2:

    2019-10-09(第二次)

    Bellman-Ford算法

    class Solution {
    public:
        int networkDelayTime(vector<vector<int>>& times, int N, int K) {

    //Bellman-Ford算法
    //存储图用邻接表,邻接矩阵需要遍历需要增加O(N)复杂度,将会升为O(N三次方)

    
            vector<int> D(N+1,-1);
            D[K] = 0;
            for(int c=0;c<N-1;++c){  //只需要N-1 轮就可以,因为D[K] 为0,是已知的 
                for(int j=0;j<times.size();++j){
                    int src = times[j][0],des = times[j][1],d = times[j][2];
                    if(D[src]!=-1&&(D[src]+d<D[des]||D[des]==-1))
                        D[des]=D[src]+d;
                }
            }
            int res = -1;
            for(int i=1;i<D.size();i++){
                if(D[i]==-1){
                    return -1;
                }
                else res = max(res,D[i]);
            }
            return res;
        }      
    };

     2019-10-05

    09:40:27

    解法3:

    Bellman-Ford 算法的优化版——SPFA(Shorest path Faster Algorithm)算法

    class Solution {
    public:
        int networkDelayTime(vector<vector<int>>& times, int N, int K) {
            vector<vector<int>> v(N+1,vector<int>(N+1,-1));
            for(int i=1;i<v.size();++i){
                v[i][i]=0;
            }
            for(int i=0;i<times.size();++i){
                v[times[i][0]][times[i][1]] = times[i][2];
            }
            vector<int> D(N+1,-1);
            D[K] = 0;
            queue<int> q;
            q.push(K);
            while(!q.empty()){
                auto temp = q.front();
                q.pop();
                for(int i=1;i<v.size();++i){
                    if(v[temp][i]!=-1 &&(v[temp][i]+D[temp]<D[i]||D[i]==-1)){
                        D[i] = v[temp][i] + D[temp];
                        q.push(i);
                    }
                }
            }
            int res = 0;
            for(int i=1;i<N+1;++i){
                if(D[i]==-1){
                    return -1;
                }
                res = max(D[i],res);
            }
            return res;
        }      
    };

    解法4:

    Floyd 算法,可用来解决全源最短路问题

    class Solution {
    public:
        int networkDelayTime(vector<vector<int>>& times, int N, int K) {
            vector<vector<int>> v(N+1,vector<int>(N+1,-1));
            for(int i=1;i<v.size();++i){
                v[i][i]=0;
            }
            for(int i=0;i<times.size();++i){
                v[times[i][0]][times[i][1]] = times[i][2];
            }
            for(int c=1;c<N+1;++c){
                for(int i=1;i<N+1;++i){
                    for(int j=1;j<N+1;++j){
                        if(v[i][c]!=-1 && v[c][j]!=-1 &&(v[i][c]+v[c][j]<v[i][j]||v[i][j]==-1)){
                            v[i][j] = v[i][c]+v[c][j];
                        }
                    }
                }
            }
            int res = 0;
            for(int i=1;i<N+1;++i){
                if(v[K][i]==-1){
                    return -1;
                }
                res = max(v[K][i],res);
            }
            return res;
        }      
    };

    解法1:

    自己写的广搜判断是否是连通图

     

    class Solution {
    public:
        bool canVisitAllRooms(vector<vector<int>>& rooms) {
            vector<vector<int>> temp(rooms.size());
            for(int i=0;i<rooms.size();++i){//初始化图
                for(int j=0;j<rooms[i].size();++j){
                    temp[i].push_back(rooms[i][j]);
                }
            }
            queue<int> q;
            q.push(0);
            vector<int> result(rooms.size(),0);
            result[0] = 1;
            while(!q.empty()){
                int c = q.front();
                q.pop();
                for(auto cnt : temp[c]){
                    if(result[cnt]!=1){
                        result[cnt] = 1;
                        q.push(cnt);
                    }
                }
            }
            for(int i=0;i<rooms.size();++i){
                if(result[i]==0){
                    return false;
                }
            }
            return true;
        }
    };

    精简版代码:

    class Solution {
    public:
        bool canVisitAllRooms(vector<vector<int>>& rooms) {
            queue<int> q;
            unordered_set<int> visited;
            q.push(0);
            visited.insert(0);
            while(!q.empty()){
                int t = q.front();q.pop();
                visited.insert(t);
                for(auto key : rooms[t]){
                    if(visited.count(key)) continue;
                    q.push(key);
                }
            }
            return visited.size() == rooms.size();
        }
    };

    解法2:DFS

    劣质粗糙代码:

    class Solution {
    public:
        int count = 0;
        void dfs(int x,int N,vector<int> &visited,vector<vector<int>> rooms){
            visited[x] = 1;
            ++count;
            for(int i=0;i<rooms[x].size();++i){
                if(!visited[rooms[x][i]]){
                    dfs(rooms[x][i],N,visited,rooms);
                }
            }
        }
        bool canVisitAllRooms(vector<vector<int>>& rooms) {
            int N = rooms.size();
            vector<int> visited(N,0);
            dfs(0,N,visited,rooms);
            return count == rooms.size();
        }
    };

     解法1:

    自己:

    找到出度为0和入度为N-1的点,此点即为法官。

     思路:构建一个出度数组和一个入度数组。

    class Solution {
    public:
        int findJudge(int N, vector<vector<int>>& trust) {
            vector<int> inDegree(N+1,0);
            vector<int> outDegree(N+1,0);
            for(auto edge : trust){
                inDegree[edge[1]]++;
                outDegree[edge[0]]++;
            }
            for(int i=1;i<N+1;++i){
                if(outDegree[i]==0 && inDegree[i]==N-1){
                    return i;
                }
            }
            return -1;
        }
    };

     

    解法1:看的评论,自己没想到,自己对DFS的掌握还是不够

    思路:DFS染色法,判断拓扑排序中是否有环,并找出不在环内的点(感觉和207,208题有些类似哦,都是判断拓扑排序中是否存在环)

    DFS一直往前走,却走回了走过的结点不就是有环了嘛.

     代码如下:

    #define CIRCLE  1
    #define TERMINAL  2
    class Solution {
    public:
        vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
            int n = graph.size();
            vector<int> v(n);
            vector<int> cnt;
            for(int i=0;i<n;++i){
                if(dfs(graph,v,i)==TERMINAL){
                    cnt.push_back(i);
                }
            }
            return cnt;
        }
        int dfs(vector<vector<int>>& g,vector<int>& v,int i){
            if(v[i]) return v[i];
            v[i] = CIRCLE;
            for(auto edge : g[i]){
                if(dfs(g,v,edge)==CIRCLE){
                    return CIRCLE;
                }
            }
            return v[i] = TERMINAL;
        }
    };

    解法2:

    BFS,和DFS的思路有很大不同。感觉两种方法的着手点是截然不同的。BFS是从入度,出度考虑的。

    class Solution {
    public:
        vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
            vector<int> res, outDegree(graph.size(),0);
            vector<vector<int>> inDegree(graph.size());
            for(int i=0;i<graph.size();++i){//初始化入队的vector<vector<int>>
                for(int j : graph[i]){
                    inDegree[j].push_back(i);
                    outDegree[i]++;
                }
            }
            for(int i=0;i<graph.size();++i){
                if(outDegree[i]==0){
                    res.push_back(i);
                }
            }
            int idx = 0;
            while(idx < res.size()){
                int i = res[idx];
                ++idx;
                for(auto j : inDegree[i]){
                    outDegree[j]--;
                    if(outDegree[j]==0){
                        res.push_back(j);
                    }
                }
            }
            sort(res.begin(),res.end());
            return res;
            
            
        }
    };

    简化版:

    class Solution {
    public:
        vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
            vector<int> res, outDegree(graph.size(),0);
            vector<vector<int>> inDegree(graph.size());
            for(int i=0;i<graph.size();++i){//初始化入队的vector<vector<int>>
                for(int j : graph[i]){
                    inDegree[j].push_back(i);
                }
                outDegree[i] = graph[i].size();
                if(outDegree[i]==0){
                    res.push_back(i);
                }            
            }
            int idx = 0;
            while(idx < res.size()){
                int i = res[idx];
                ++idx;
                for(auto j : inDegree[i]){
                    outDegree[j]--;
                    if(outDegree[j]==0){
                        res.push_back(j);
                    }
                }
            }
            sort(res.begin(),res.end());
            return res;
        }
    };

     为下面代码做铺垫的新知识:

     https://www.cnblogs.com/hustfeiji/articles/5174983.html

     这就是说multiset内部是自动排好序的。

    解法1:

    思路:DFS

     

    class Solution {
    public:
        map<string, multiset<string>> targets;
        vector<string> route;
        vector<string> findItinerary(vector<vector<string>>& tickets) {
            for (auto ticket : tickets)
                targets[ticket[0]].insert(ticket[1]);
            visit("JFK");
            return vector<string>(route.rbegin(), route.rend());
        }
    
    void visit(string airport) {
        while (targets[airport].size()) {
            string next = *targets[airport].begin();
            targets[airport].erase(targets[airport].begin());
            visit(next);
        }
        route.push_back(airport);
    }
    
    };

    本题是一道树的题目。

    就是返回每层各个元素相加和的最大的那个层 

    法1:

    BFS

    class Solution {
    public:
        int maxLevelSum(TreeNode* root) {
            queue<TreeNode*> q;
            q.push(root);
            int maxv=root->val,res=1,layer=0;
            while(!q.empty()){
                layer++;
                int n=q.size(),sum=0;
                for(int i=0;i<n;i++){
                    TreeNode* tmp=q.front();q.pop();
                    sum+=tmp->val;
                    if(tmp->left) q.push(tmp->left);
                    if(tmp->right) q.push(tmp->right);
                }
                if(sum>maxv){
                    maxv=sum;
                    res=layer;
                }
            }
            return res;
        }
    };

    法2:

    DFS:

    借助map结构,遍历到各个层时,map[n] 就加上那个属于本层的节点的元素值。 

    class Solution {
    public:
        map<int,int> mp;
        void dfs(TreeNode* root, int d){
            if(!root){
                return;
            }
            mp[d] += root->val;
            dfs(root->left,d+1);
            dfs(root->right,d+1);
        }
        int maxLevelSum(TreeNode* root) {
            int res = 0, max_sum = INT_MIN;
            dfs(root,1);
            auto iter = mp.begin();
            while(iter != mp.end()){
                if(iter->second > max_sum){
                    max_sum = iter->second;
                    res = iter->first;
                }
                iter++;
            }
            return res;
        }
    };

     解法1:

    并查集

    题目很拗口。。。但本质就是计算一个图的连通分量的个数,总石头数减去连通分量个数就是结果。

    每次move移除掉一个共享同一行或列的(两个或多个石头)中的一个 如果把每个石头当一个点,如果两个石头间有共同x或y坐标,就给这两个点画一条线(边)。那么对应move操作就是把其中一条边的一个点删除,直到不能删为止,也就是说图里面的连通分量的点是要删去的,一直删到连通分量里面没有边(即只剩下一个点)

     

    class Solution {
    public:
        vector<int> vec;
        int removeStones(vector<vector<int>>& stones) {
            int n = stones.size();
            vec = vector<int>(n);
            for(int i=0;i<n;++i){
                vec[i] = i;
            }
            for(int i=0;i<n;++i){
                for(int j=0;j<n;++j){
                    if(stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]){
                        Union(i,j);
                    }
                }
            }
            int cnt=0;
            for(int i=0;i<n;++i){
                if(vec[i]==i){
                    cnt++;
                }
            }
            return n - cnt;
        }
        int find(int i){
            if(vec[i]!=i){
                vec[i] = find(vec[i]);
            }
            return vec[i];
        }
        void Union(int x,int y){
            int faA = find(x);
            int faB = find(y);
            vec[faA] = faB;
        }
    };

    解法2:

    DFS

    DFS方法的解题思路: 用dfs求连通分量的个数 最后结果 = stones.size() - 连通分量的个数

    class Solution {
    public:
        int removeStones(vector<vector<int>>& stones) {
            vector<bool> vis(stones.size(),false);
            int res = 0;
            for(int i=0;i<stones.size();++i){
                if(vis[i]==true){
                    continue;
                }
                dfs(stones,vis,i);
                res++;
            }
            return stones.size()-res;
        }
        void dfs(vector<vector<int>>& stones,vector<bool>& vis,int k){
            vis[k] = true;
            int x = stones[k][0], y = stones[k][1];
            for(int i=0;i<stones.size();++i){
                if(vis[i]==true)
                    continue;
                if(stones[i][0] == x || stones[i][1]==y){
                    dfs(stones,vis,i);
                }
            }
        }
    };

     

    解法1:

    并查集

     

    class Solution {
    public:
        
        int find(vector<int>& union_find, int idx){
            if(union_find[idx] == -1)   return idx;
            return find(union_find,union_find[idx]);
        }
        
        void Union(vector<int>&union_find, int idx1, int idx2){
            int parent1 = find(union_find,idx1);
            int parent2 = find(union_find,idx2);
            //Always keep the same rule, merge parent1 to parent2;
            if(parent1 != parent2)  union_find[parent1] = parent2;
        }
    
        vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
            vector<vector<string>> res;
            int n = accounts.size();
            
            vector<int> union_find(n,-1);
            map<string,int> mailUser;
            map<int,vector<string>> mails;
            
            for(int i=0; i<accounts.size(); i++){
                for(int j=1; j<accounts[i].size(); j++){
                    if(mailUser.count(accounts[i][j])){
                        // if the same email has been stored before, find its user and unite them
                        int idx1 = find(union_find,i);
                        int idx2 = find(union_find,mailUser[accounts[i][j]]);
                        Union(union_find,idx1,idx2);
                    }
                    //**IMPORTANT** 
                    //We can still assign this mail to the "current" user, because we have already performed union
                    mailUser[accounts[i][j]] = i;
                }
            }
            
            for(auto pair:mailUser){
                //Find its real user
                int user = find(union_find,pair.second);
                mails[user].push_back(pair.first);
            }
            
            for(auto pair:mails){
                vector<string> temp = pair.second;
                sort(temp.begin(),temp.end());
                temp.insert(temp.begin(),accounts[pair.first][0]);
                res.push_back(temp); 
            }
            
            return res;
        }
    };

     

    解法1:
    DFS C++

     

    class Solution {
    private:
        unordered_map<string,vector<pair<string,double>>> children;
        pair<bool,double> search(string& a,string& b,unordered_set<string>& visited,double val){
            if(visited.count(a) == 0){
                visited.insert(a);
                for(auto p : children[a]){
                    double temp = val * p.second;
                    if(p.first == b) return make_pair(true,temp);
                    auto result = search(p.first,b,visited,temp);
                    if(result.first){
                        return result;
                    }
                }
            }
            return make_pair(false,-1.0);
        }
    public:
        vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
            vector<double> ans;
            for(int i = 0;i<equations.size();++i){
                children[equations[i][0]].push_back(make_pair(equations[i][1],values[i]));
                children[equations[i][1]].push_back(make_pair(equations[i][0],
                                                                  1.0 / values[i]));
            }
            for(auto p : queries){
                unordered_set<string> visited;
                // p .first == p.second is special case
                ans.push_back(p[0] == p[1] && children.count(p[0]) ? 
                              1.0 : search(p[0],p[1],visited,1.0).second);
            }
            return ans;
            
        }
    };

     

     

    class Solution {
    public:
        int maxPoints(vector<vector<int>>& points) {
            //两点确定一条直线
            if(points.size()<3)return points.size();
            
            int Max=0;
            for(int i=0;i<points.size();++i)//i表示数组中的第i+1个点
            {
                //same用来表示和i一样的点
                int same=1;
                for(int j=i+1;j<points.size();++j)//j表示数组中的第j+1个点
                {
                    int count=0;
                    // i、j在数组中是重复点,计数
                    if(points[i][0]==points[j][0]&&points[i][1]==points[j][1])same++;
                    else{//i和j不是重复点,则计算和直线ij在一条直线上的点
                        count++;
                        long long xDiff = (long long)(points[i][0] - points[j][0]);//Δx1
                        long long yDiff = (long long)(points[i][1] - points[j][1]);//Δy1
                        
                        for (int k = j + 1; k < points.size(); k ++)//Δy1/Δx1=Δy2/Δx2 => Δx1*Δy2=Δy1*Δx2,计算和直线ji在一条直线上的点
                            if (xDiff * (points[i][1] - points[k][1]) == yDiff * (points[i][0] - points[k][0]))
                                count++;
                    }
                    Max=max(Max,same+count);
                }
                if(Max>points.size()/2)return Max;//若某次最大个数超过所有点的一半,则不可能存在其他直线通过更多的点
            }
            return Max;
        }
    };

  • 相关阅读:
    leetcode 48. Rotate Image
    leetcode 203. Remove Linked List Elements 、83. Remove Duplicates from Sorted List 、82. Remove Duplicates from Sorted List II(剑指offer57 删除链表中重复的结点) 、26/80. Remove Duplicates from Sorted ArrayI、II
    leetcode 263. Ugly Number 、264. Ugly Number II 、313. Super Ugly Number 、204. Count Primes
    leetcode 58. Length of Last Word
    安卓操作的一些问题解决
    leetcode 378. Kth Smallest Element in a Sorted Matrix
    android studio Gradle Build速度加快方法
    禁用gridview,listview回弹或下拉悬停
    Android Studio找不到FragmentActivity类
    安卓获取ListView、GridView等滚动的距离(高度)
  • 原文地址:https://www.cnblogs.com/JasonPeng1/p/12110098.html
Copyright © 2011-2022 走看看