Day30 回溯 LeedCode 332.重新安排行程 51. N皇后 37. 解数独 蓝桥杯 与或异或

已于 2024-04-08 13:42:32 修改
阅读量1k 收藏 13
点赞数 22
文章标签： java 算法
于 2024-04-04 20:40:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76352996/article/details/137375607
版权

332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

  • 例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

示例 1：

输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]
输出：["JFK","MUC","LHR","SFO","SJC"]

本题用回溯法,遍历所有的票的使用顺序,由于所有机票至少存在一种合理的行程,我们先将票按照起始位置的开头字母小的排序,递归过程中找到其中一种合理行程就返回,该行程一定是字典排序更小的行程。

递归三部曲:

1.确定返回值和参数的类型

使用全局变量保存结果 ,参数传入所有的票(List<List<String>> tickets),和每张票的使用情况(used[])

由于只取第一个结果,所有返回值类型设置为boolean类型,当找到第一个结果时,就返回true

 List<String> path=new LinkedList<>();
    List<String> result;
boolean travel(List<List<String>> tickets,boolean used[])

2.确定递归结束条件

当记录路径的数组的长度==票的长度+1,说明合理用完了所有票,找到了合理旅游路径,结束递归

   if(path.size()==tickets.size()+1){
            result=new ArrayList<>(path);
            return true;
        }

3.单层递归逻辑

递归找到所有方案

 for(int i=0;i<tickets.size();i++){
            if(!used[i]&&path.get(path.size()-1).equals(tickets.get(i).get(0))){
              path.add(tickets.get(i).get(1));
              used[i]=true;
              //找到第一个方案,结束递归
            if( travel(tickets,used))return true;
              path.remove(path.size()-1);
              used[i]=false;
            }

        }
        return false;

总体代码:

class Solution {
    List<String> path=new LinkedList<>();
    List<String> result;
    public List<String> findItinerary(List<List<String>> tickets) {
       boolean[] used=new boolean[tickets.size()];
       //给票排序
       Collections.sort(tickets,(a,b)->a.get(1).compareTo(b.get(1)));
       path.add("JFK");
       travel(tickets,used);
       return result;
    }
    boolean travel(List<List<String>> tickets,boolean used[]){
        if(path.size()==tickets.size()+1){
            result=new ArrayList<>(path);
            return true;
        }
        for(int i=0;i<tickets.size();i++){
            if(!used[i]&&path.get(path.size()-1).equals(tickets.get(i).get(0))){
              path.add(tickets.get(i).get(1));
              used[i]=true;
              //找到第一个方案,结束递归
            if( travel(tickets,used))return true;
              path.remove(path.size()-1);
              used[i]=false;
            }

        }
        return false;
    }
}

使用本方法因为排序的原因会出现超时 

改进方法:

用Map<出发机场, Map<到达机场, 航班次数>> map来记录车票,Map<到达机场, 航班次数>为升序TreeMap

class Solution {
    private Deque<String> res;
    private Map<String, Map<String, Integer>> map;

    private boolean backTracking(int ticketNum){
        if(res.size() == ticketNum + 1){
            return true;
        }
        String last = res.getLast();
        if(map.containsKey(last)){//防止出现null
            for(Map.Entry<String, Integer> target : map.get(last).entrySet()){
                int count = target.getValue();
                if(count > 0){
                    res.add(target.getKey());
                    target.setValue(count - 1);
                    if(backTracking(ticketNum)) return true;
                    res.removeLast();
                    target.setValue(count);
                }
            }
        }
        return false;
    }

    public List<String> findItinerary(List<List<String>> tickets) {
        map = new HashMap<String, Map<String, Integer>>();
        res = new LinkedList<>();
        for(List<String> t : tickets){
            Map<String, Integer> temp;
            if(map.containsKey(t.get(0))){
                temp = map.get(t.get(0));
                temp.put(t.get(1), temp.getOrDefault(t.get(1), 0) + 1);
            }else{
                temp = new TreeMap<>();//升序Map
                temp.put(t.get(1), 1);
            }
            map.put(t.get(0), temp);

        }
        res.add("JFK");
        backTracking(tickets.size());
        return new ArrayList<>(res);
    }
}

本题难在容器的选择

51. N 皇后 - 力扣（LeetCode）

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

Example 1:

Input: n = 4
Output: [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

皇后们的约束条件：

  1. 不能同行
  2. 不能同列
  3. 不能同斜线
 Boolean isVaild(char[][] chessboard,int row,int col,int n){
        //把皇后放在n*n的棋盘的(row,col)位置
        //检查列
        for(int i=0;i<row;i++){
            if(chessboard[i][col]=='Q')
            return false;
        }
        //检查45°对角线
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
            if(chessboard[i][j]=='Q')
            return false;
        }
        //检查135度对角线
        for(int i=row-1,j=col+1;i>=0&&j<=n-1;i--,j++){
       if(chessboard[i][j]=='Q')
            return false;
        }
     return true;
    }

 思路:用回溯法,遍历出所有可以放置的可能性

递归三部曲:

1.确定返回值和参数类型

要把所有能摆放的位置都得出,用全局变量public List<List<String>> result=new ArrayList<>();记录所有合理的棋盘,返回值为void,传入棋盘(char[][] chessboard),要放置的皇后在哪一行(int row),棋盘的宽度(n);

 public void backTracking(int n,int row,char[][] chessboard)

2.确定递归结束条件

当row==n时,说明所有行都放置了皇后,找到了一种合理放法,将该棋盘存入result中,递归结束

 if(row==n){
           List<String> temp= array2List(chessboard);
           result.add(temp);
           return;
       }

3.确定单层递归逻辑

遍历该行的每一个位置并检查其合理性,如果合理,进入下一行棋盘的摆放

for(int i=0;i<n;i++){
        //如果当前位置合法,就递归放下一行
        if(isVaild(chessboard,row,i,n)){
        chessboard[row][i]='Q';
        backTracking(n,row+1,chessboard);
        chessboard[row][i]='.';
        }
       }

总体代码:

class Solution {
    public List<List<String>> result=new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
       char[][] chessboard = new char[n][n];
       for(char[] c:chessboard){
        Arrays.fill(c,'.');
       }
       backTracking(n,0,chessboard);
       return result;
    }
    public void backTracking(int n,int row,char[][] chessboard){
       if(row==n){
           List<String> temp= array2List(chessboard);
           result.add(temp);
           return;
       }
       for(int i=0;i<n;i++){
        //如果当前位置合法,就递归放下一行
        if(isVaild(chessboard,row,i,n)){
        chessboard[row][i]='Q';
        backTracking(n,row+1,chessboard);
        chessboard[row][i]='.';
        }
       }

    }
    //将数组转为list
    List<String> array2List(char[][] chessboard){
        List<String> result=new ArrayList<>();
        for(int i=0;i<chessboard.length;i++){
             StringBuilder temp=new StringBuilder();
        for(int j=0;j<chessboard[0].length;j++){
           temp.append(chessboard[i][j]);
        }
        result.add(temp.toString());
        }
        return result;
    }

    Boolean isVaild(char[][] chessboard,int row,int col,int n){
        //把皇后放在n*n的棋盘的(row,col)位置
        //检查列
        for(int i=0;i<row;i++){
            if(chessboard[i][col]=='Q')
            return false;
        }
        //检查45°对角线
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
            if(chessboard[i][j]=='Q')
            return false;
        }
        //检查135度对角线
        for(int i=row-1,j=col+1;i>=0&&j<=n-1;i--,j++){
       if(chessboard[i][j]=='Q')
            return false;
        }
     return true;
    }
}

37. 解数独

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

  1. 数字 1-9 在每一行只能出现一次。
  2. 数字 1-9 在每一列只能出现一次。
  3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

示例 1：

输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]]
输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
解释：输入的数独如上图所示，唯一有效的解决方案如下所示：
 

 

思路:n皇后问题一行只需要放一个皇后,本题一行可能填好几个数,所以本题是二维递归 ,
 

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！
 

 

 

判断棋盘是否合法
 

判断棋盘是否合法有如下三个维度：
 

  • 同行是否重复
  • 同列是否重复
  • 9宫格里是否重复
 

  Boolean isVaild(int row,int col,char val,char[][] board){
        //同行是否重复
        for(int i=0;i<9;i++){
            if(board[row][i]==val){
                return false;
            }
        }
        //同列是否重复
        for(int i=0;i<9;i++){
            if(board[i][col]==val){
                return false;
            }
        }
        //9宫格内是否重复
        int startRow=row/3*3;
        int startCol=col/3*3;
        for(int i=startRow;i<startRow+3;i++){
            for(int j=startCol;j<startCol+3;j++){
        if(board[i][j]==val){
            return false;
              }
            }
        }
      return true;
    }
 

 递归三部曲:
 

1.确定返回值和参数类型
 

只有一个解,只需要找一个解,返回类型为boolean,当回溯返回true时,结束当前递归
 

 Boolean backTracking(char[][] board)
 

当有多个解时,返回类型为void,需要找遍所有可能
 

传入棋盘char[][] board
 

2.确定递归结束条件
 

本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。
 

递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！
 

3.确定当层逻辑
 

 
 
一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！
 

 

class Solution {
    public void solveSudoku(char[][] board) {
      backTracking(board);
    }
    Boolean backTracking(char[][] board){
         for (int i = 0; i < 9; i++){ // 遍历行
            for (int j = 0; j < 9; j++){ // 遍历列
                if (board[i][j] != '.'){ // 跳过原始数字
                    continue;
                }
                //找到没填数字的空位,在这个空位填1--9
                for(char k='1';k<='9';k++){
                    if(isVaild(i,j,k,board)){
                        board[i][j]=k;
                    if(backTracking(board))return true;
                    board[i][j]='.';//
                    }
                   
                }
                return false;//9个数都填了,都不对,返回false
            }

         }
            //遍历完没有返回false，说明找到了合适棋盘位置了
                return true;
            
    }


    Boolean isVaild(int row,int col,char val,char[][] board){
        //同行是否重复
        for(int i=0;i<9;i++){
            if(board[row][i]==val){
                return false;
            }
        }
        //同列是否重复
        for(int i=0;i<9;i++){
            if(board[i][col]==val){
                return false;
            }
        }
        //9宫格内是否重复
        int startRow=row/3*3;
        int startCol=col/3*3;
        for(int i=startRow;i<startRow+3;i++){
            for(int j=startCol;j<startCol+3;j++){
        if(board[i][j]==val){
            return false;
              }
            }
        }
      return true;
    }
}
 

 

 

思路:本题与上一题思路一致, 一个for循环遍历数组的行，一个for循环遍历数组的列，一行一列确定下来之后，遍历所有符号得出这个位置的数！
 

代码参考:
 

import com.sun.org.apache.bcel.internal.generic.NEW;


import java.util.*;

public class Main {
    static int[][] result = new int[5][5];
    static int sum = 0;
    static char[] f = {'&', '|', '^'};

    public static void main(String args[]) {
        int[] A = {1, 0, 1, 0, 1};
        for (int i = 1; i < result.length; i++)
            Arrays.fill(result[i], -1);
        result[0] = A;

        backTracking(result);
        System.out.println(sum);
    }

    public static void backTracking(int[][] result) {
        if (result[4][0] != -1) {
            if (result[4][0] == 1)
                sum++;
            result[4][0] = -1;
            return;
        }

        for (int k = 1; k < 5; k++) {
            for (int m = 0; m < 5 - k; m++) {
 //找到没填数字的空位
                if (result[k][m] != -1)
                    continue;
//遍历所有符号,填上对应的数
                for (int n = 0; n < f.length; n++) {
                    result[k][m] = fun(f[n], result[k - 1][m], result[k - 1][m + 1]);
                    backTracking(result);
                    result[k][m] = -1;
                }
                return;//遍历完当前所有符号,
//表示这个位置填某一个符合的计算结果情况已经遍历完了,
//返回上一层,将上一个数修改
            }
        }
    }

    public static int fun(char a, int b, int c) {
        if (a == '&') {
            return b & c;
        } else if (a == '|') {
            return b | c;
        } else
            return b ^ c;

    }


}


 

 

 


                

        

        

    




    

      

        

            

              
                
                  魔法少女小严
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    22
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    13
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
javascript-leetcode面试题解递归与回溯问题之第51题N皇后-题解.zip

				
			

			

				

					03-15
				

			

		

		

			
				
javascript javascript_leetcode面试题解递归与回溯问题之第51题N皇后_题解

			
		

	



                

              
                



	

		

			

				
					
C语言入门-leetcode练习之第51题N皇后.zip

					
最新发布

				
			

			

				

					05-26
				

			

		

		

			
				
c语言入门 C语言入门_leetcode练习之第51题N皇后

			
		

	



                


  
              

                


	

		

			

				
					
LeetCode每日一题 DAY2 剑指 Offer II 067. 最大的异或

				
			

			

				

					jmk0614的博客
				

				

					08-13
					
					1157
					
				

			

		

		

			
				
刷题打卡

			
		

	





	

		

			

				
					
leetcode刷题记录2：进度64， 2021.10.23

				
			

			

				

					leogo17的博客
				

				

					11-12
					
					515
					
				

			

		

		

			
				
文章目录数组的度（题目编号697：[link](https://leetcode-cn.com/problems/degree-of-an-array/)）二叉搜索树（题目编号700：[link](https://leetcode-cn.com/problems/search-in-a-binary-search-tree/)）数据流中的第K大元素（题目编号703：[link](https://leetcode-cn.com/problems/kth-largest-element-in-a-stream/

			
		

	



		

			
		



	

		

			

				
					
1.leetcode

				
			

			

				

					weixin_45521101的博客
				

				

					11-21
					
					612
					
				

			

		

		

			
				
Leetcode刷题记录数组
数组
1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

//暴力求解
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> 

			
		

	





	

		

			

				
					
算法刷题总结 (二) 回溯与深广搜与并查集算法

				
			

			

				

					UK - UofL HW - SDE
				

				

					03-23
					
					1290
					
				

			

		

		

			
				
回溯与深广搜有相似的做法和理解，所以把他们放在同一个文章之中，文章看似篇幅很长，实际上，题目都是相似的，顺着章节来可以很快的掌握这个算法内容，以后碰到这样的相似题目，会很快想出思路。

回溯是递归的纵横拓展，主要是递归（纵）+局部暴力枚举（横）。所以可以从递归和暴力两个方面来拆解回溯问题。

			
		

	





	

		

			

				
					
AcWing 算法基础课学习记录（Python，备战蓝桥杯）Day1 - Day30

				
			

			

				

					Devlegal的博客
				

				

					10-13
					
					4878
					
				

			

		

		

			
				
算法，ACM，蓝桥杯

			
		

	





	

		

			

				
					
蓝桥杯python知识总结(详细)

					
热门推荐

				
			

			

				

					qq_46500711的博客
				

				

					04-30
					
					4万+
					
				

			

		

		

			
				
最近成绩下来了，省一，就把之前刷题时总结下来的知识分享给大家，涵盖了python大部分知识点，包括python知识、力扣题所涵盖的知识点、以及一些有意思的题

			
		

	





	

		

			

				
					
leetcode

				
			

			

				

					myles_的博客
				

				

					04-12
					
					1779
					
				

			

		

		

			
				
leetcode刷题之路
discription:之前刷过leetcode，但是因为决心不坚定以及一直弄不明白leetcode编辑器的原理，所以一直断断续续，现在下定决心每天两道又简单到困难，算是为以后铺路。
本文章就是为了记录刷题的心得和源代码
day 1
Q1 两数之和
class Solution(object):
    def twoSum(self, nums, target):
       for i in range(0, len(nums)):
        for j in rang

			
		

	





	

		

			

				
					
【LeetCode】Day163-字母大小写全排列

				
			

			

				

					qq_43417265的博客
				

				

					10-21
					
					101
					
				

			

		

		

			
				
784. 字母大小写全排列【中等】-回溯、位运算

			
		

	





	

		

			

				
					
Day65（回溯——棋盘）

				
			

			

				

					qq_51329170的博客
				

				

					03-28
					
					406
					
				

			

		

		

			
				
51、N 皇后

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。




class Solution {
    //使其中任意两个皇后都不同列、同行和在一条斜线上"
    List<List<String>> ans = new ArrayList<&g

			
		

	





	

		

			

				
					
c++-c++编程基础之leetcode题解第51题N皇后.zip

				
			

			

				

					04-08
				

			

		

		

			
				
c++ c++_c++编程基础之leetcode题解第51题N皇后

			
		

	





	

		

			

				
					
用C语言实现Leetcode题目.zip

				
			

			

				

					03-16
				

			

		

		

			
				
用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现...

			
		

	





	

		

			

				
					
hackerchenzhuo#ccf_pat_leetcode.etc#leetcode 22.括号生成【回溯】1

				
			

			

				

					07-25
				

			

		

		

			
				
原创：leetcode 22.括号生成【回溯】对待这种问题，千万别暴力搜索，那样太笨了。但是这个方法是最容易理解的//回溯法 (后面的括号) 不可以大于 (前面

			
		

	





	

		

			

				
					
java学习和项目总结

				
			

			

				

					2301_79390585的博客
				

				

					05-24
					
					698
					
				

			

		

		

			
				
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；

			
		

	





	

		

			

				
					
Java高级面试精粹：问题与解答集锦（一）

				
			

			

				

					Layla_c的博客
				

				

					05-23
					
					1443
					
				

			

		

		

			
				
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。

			
		

	





	

		

			

				
					
JVM学习-执行引擎

				
			

			

				

					丢爸
				

				

					05-21
					
					1151
					
				

			

		

		

			
				
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。

			
		

	





	

		

			

				
					
数据访问与Spring Data JPA

				
			

			

				

					无远弗届
				

				

					05-25
					
					531
					
				

			

		

		

			
				
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {

			
		

	





	

		

			

				
					
leetcode 2031. 1 比 0 多的子数组个数

				
			

			

				

					12-16
				

			

		

		

			
				
leetcode 2031题是一道有关于子数组的问题。问题的要求是求出给定数组中，1的个数比0多的子数组的个数。我们可以通过遍历数组的每个元素，然后计算以该元素结尾的子数组中，1的个数比0多的个数。

我们可以定义一个变量count，用来记录当前遍历到的元素前面的子数组中，1的个数比0多的个数。初始化count为0。然后开始遍历数组。

对于当前遍历的元素，如果是1，则count加1。如果是0，则count减1。然后判断count的值。

如果count大于0，则说明当前元素前面的子数组中，1的个数比0多，我们将结果加上count。

如果count等于0，则说明当前元素前面的子数组中，1的个数和0的个数相等，我们将结果加上1，表示当前子数组中加上这个元素后，1的个数比0多。

最后，我们将结果返回，即为所求的答案。

下面是具体的代码实现：
```python
def countSubarrays(nums):
    count = 0
    result = 0

    for num in nums:
        if num == 1:
            count += 1
        else:
            count -= 1

        if count > 0:
            result += count
        elif count == 0:
            result += 1
    
    return result
```

以上就是针对leetcode 2031题的问题，求解1比0多的子数组个数的详细解答。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值