力 扣 数 据 结 构 与 算 法

JAVA之路day15-力扣算法练习
力扣（leetcode）算法练习
地图分析
import java.util.ArrayDeque;
-*你现在手里有一份大小为 N x N 的『地图』（网格） grid，上面的每个『区域』（单元格）都用 0 和 1 标记好了。

其中 0 代表海洋，1 代表陆地，你知道距离陆地区域最远的海洋区域是是哪一个吗？请返回该海洋区域到离它最近的陆地区域的距离。

我们这里说的距离是『曼哈顿距离』（ Manhattan Distance）：(x0, y0) 和 (x1, y1) 这两个区域之间的距离是 |x0 - x1| + |y0 - y1| 。

如果我们的地图上只有陆地或者海洋，请返回 -1。

输入：[[1,0,1],[0,0,0],[1,0,1]]
海洋区域 (1, 1) 和所有陆地区域之间的距离都达到最大，最大距离为 2。

public class Demo01 {
public static void main(String[] args) {
int[][] grid={
{1,0,1},
{0,0,0},
System.out.println(maxDistance(grid));
public static int maxDistance(int [][] grid){
int[] x={0,0,-1,1};
int[] y={1,-1,0,0};--用于移动坐标，对应上下左右
--创建一个队列，将陆地压入队列
ArrayDequeint[] deque=new ArrayDeque();
int m = grid.length;--有m行
int n = grid[0].length;--n列
for (int i=0;im;i++){
for (int j=0;jn;j++){
if (grid[i][j]==1)deque.offer(new int[] {i,j});
--当队列不为空的时候，将陆地四周的海洋用距离标记，并在标记的海洋上再次向四周扩散，并标记距离
boolean bool=false;
int[] poll=null;
while (!deque.isEmpty()){
poll = deque.poll();--将队列头的陆地坐标弹出来
--把陆地临近四个方向的海洋标记
int newX,newY;--被扩散的海洋的坐标
for (int i=0;i4;i++){
newX=x[i]+poll[0];
newY=y[i]+poll[1];
if
(newX0||newX=m||newY0||newY=n||grid[newX][newY]!=0)continue;
grid[newX][newY]=grid[poll[0]][poll[1]]+1;--相邻的格子，所以距离+1，直接使用原数组记录距离
deque.offer(new int[] {newX,newY});
bool=true;
--判断是否全是陆地或全是海洋
if (poll==null||!bool){return -1;}
return grid[poll[0]][poll[1]]-1;
买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。

public class Demo02 {
public static int maxProfit(int[] prices) {
int l=prices.length;
int max=0;
for (int i=0;il-1;i++){
for (int j=i+1;jl;j++){
if (prices[j]-prices[i]max)max=prices[j]-prices[i];
return max;
public static void main(String[] args) {
int[] a={1,5,2,6,3,4,5,9,1,3,4};
System.out.println(maxProfit(a));
买卖股票的最佳时机Ⅱ
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。

你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

public class Demo03 {
public int maxProfit(int[] prices) {
int max=0;
int length = prices.length;
for (int i=0;ilength-1;i++){
if (prices[i]prices[i+1]){max+=prices[i+1]-prices[i];}
return max;
二倍速对数组
import java.util.Arrays;
import parator;
import java.util.HashMap;
import java.util.Map;
给定一个长度为偶数的整数数组 A，只有对 A 进行重组后可以满足
“对于每个 0 = i len(A) - 2，都有A[2 * i + 1] = 2 * A[2 * i]” 时，
返回 true；否则，返回 false。

输入：[3,1,3,6] [4,-2,2,-4]
输出：false true
public class Demo04 {
public static boolean canReorderDoubled(int[] A) {
--用HashMap集合记录数组中的数有没有被访问过
MapInteger,Integer hm=new HashMap();
for (int i:A){
hm.put(i,hm.getOrDefault(i, 0) + 1);--精髓所在，如果存在了一个主键值，则值加一
--创建一个新的数组B，按A中数的绝对值大小从小到大排序
Integer[] B=new Integer[A.length];
for (int j=0;jA.length;j++){
B[j]=A[j];
Arrays.sort(B, paringInt(Math::abs));--按绝对值从小到大排序
--遍历数组B，如果hm的主键x没有被访问，则必须有hm的主键2x 没有被访问，否则false
for (int x:B){
if (hm.get(x)==0)continue;--说明这个主键被访问过了并且所有同主键值的数已经匹配完
if (hm.getOrDefault(2*x,0)==0){--没有被访问并且没有对应的主
键值
return false;
--改变被访问的一组数的主键值
hm.put(x,hm.get(x)-1);
hm.put(2*x,hm.get(2*x)-1);
--如果上面判断都通过则为真
return true;
public static void main(String[] args) {
System.out.println(canReorderDoubled(new int[]{4,-2,2,-4}));
我们把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。

求按从小到大的顺序的第 n 个丑数。

输入n，输出从小到大排列第n个丑数
public class Demo05 {
public static void main(String[] args) {
for (int i=1;i100;i++){
System.out.println(nthUglyNumber(i));
public static int nthUglyNumber(int n){
int p2=0,p3=0,p5=0;
int[] ints = new int[n];
ints[0]=1;
for (int i=1;in;i++){
ints[i]=Math.min(ints[p2]*2,Math.min(ints[p3]*3,ints[p5]*5));
if (ints[i]==ints[p2]*2)p2++;
if (ints[i]==ints[p3]*3)p3++;
if (ints[i]==ints[p5]*5)p5++;
return ints[n-1];
* LRUCache obj = new LRUCache(capacity);
ans = (ans + m) % i;
if (i==0){--第一次循环的时候
return first and self.isMatch(s[1:], p[1:])
int right = height.size() -1;
for (int num : nums) {
输入: nums = [4,5,6,7,0,1,2], target = 3
for (int i = 0; i nodes.length; i++) {
while deq and nums[i] nums[deq[-1]]:
设计一个算法来计算你所能获取的最大利润。

你可以尽可能地完成更多的交易（多次买卖一支股票）。