leetcode刷题（四）java

最新推荐文章于 2023-01-26 12:06:57 发布

原创最新推荐文章于 2023-01-26 12:06:57 发布 · 265 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #java

java 同时被 2 个专栏收录

8 篇文章

订阅专栏

leetcode

7 篇文章

订阅专栏

本文介绍了三种数组操作的方法：分割数组使其左侧元素都不大于右侧元素，并返回左侧长度；寻找数组的中心下标，即左侧元素之和等于右侧元素之和的位置；在二维网格中计算从起点到终点的不同路径数量，要求经过所有无障碍方格。

10.分割数组

给定一个数组 A，将其划分为两个连续子数组 left 和 right，使得：

left 中的每个元素都小于或等于 right 中的每个元素。
left 和 right 都是非空的。
left 的长度要尽可能小。

在完成这样的分组后返回 left 的长度。可以保证存在这样的划分方法。

class Solution {
    public int partitionDisjoint(int[] A) {
        int n=A.length;
        int[] ans=new int[n];
        ans[0]=1;
        int m=A[0],t=A[0];
        for(int i=1;i<n;i++)
        {
            if(A[i]<m)
            {
                ans[i]=i+1;
                m=t;
            }
            else
            {
                ans[i]=ans[i-1];
                if(A[i]>=t)
                {
                    t=A[i];
                }
            }
        }
        return ans[n-1];

    }
}

11.寻找中心下标

给你一个整数数组 nums，请编写一个能够返回数组 “中心下标” 的方法。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心下标，返回 -1 。如果数组有多个中心下标，应该返回最靠近左边的那一个。

**注意：**中心下标可能出现在数组的两端。

class Solution {
    public int pivotIndex(int[] nums) {
        int sum1=0,sum2=0;
        int n=nums.length;
        if(n==0)
        {
            return -1;
        }
        if(n==1)
        {
            return 0;
        }
        for(int i=1;i<n;i++)
        {
            sum2=sum2+nums[i];
        }
        if(sum1==sum2)
        {
            return 0;
        }
        for(int i=1;i<n;i++)
        {
            sum1=sum1+nums[i-1];
            sum2=sum2-nums[i];
            if(sum1==sum2)
            {
                return i;
            }
        }
        return -1;
        
    }
}

12.不同路径III

在二维网格 grid 上，有 4 种类型的方格：

1 表示起始方格。且只有一个起始方格。
2 表示结束方格，且只有一个结束方格。
0 表示我们可以走过的空方格。
-1 表示我们无法跨越的障碍。

返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目**。**

每一个无障碍方格都要通过一次，但是一条路径中不能重复通过同一个方格。

class Solution {
    
    public static int dps(int[][] grid,int i,int j,int m,int n,int s,int l)//i,j是当前位置
    {
        int ans=0;
        if(i<0||j<0||i>=m||j>=n||grid[i][j]==-1||grid[i][j]==1)
        {
            return 0;
        }
        else if(grid[i][j]==2)
        {
            if(s==l)
            {
                return 1;
            }
            else{
                return 0;
            }
        }
        else
        {
            if(grid[i][j]==0)
            {
                s=s+1;
                grid[i][j]=-1;
                ans=ans+dps(grid,i+1,j,m,n,s,l);
                ans=ans+dps(grid,i,j+1,m,n,s,l);
                ans=ans+dps(grid,i-1,j,m,n,s,l);
                ans=ans+dps(grid,i,j-1,m,n,s,l);
                grid[i][j]=0;
            }
        }
        return ans;
    }

    public int uniquePathsIII(int[][] grid) {
        int ans=0;
        int m=grid.length,n=grid[0].length;
        int l=0;
        int start_i=0,start_j=0;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(grid[i][j]==1)
                {
                    start_i=i;
                    start_j=j;
                }
                if(grid[i][j]==0)
                {
                    l=l+1;
                }
            }
        }
        int i=start_i,j=start_j;
        int s=0;
        ans=ans+dps(grid,i+1,j,m,n,s,l);
        s=0;
        i=start_i;
        j=start_j;
        ans=ans+dps(grid,i,j+1,m,n,s,l);
        s=0;
        i=start_i;
        j=start_j;
        ans=ans+dps(grid,i-1,j,m,n,s,l);
        s=0;
        i=start_i;
        j=start_j;
        ans=ans+dps(grid,i,j-1,m,n,s,l);
        return ans;
    }
}