LeetCode 64最小路径和&65有效数字&66加一

最新推荐文章于 2024-07-06 07:33:24 发布

程序员bigsai

最新推荐文章于 2024-07-06 07:33:24 发布

阅读量2.7k

点赞数 3

分类专栏： LeetCode 文章标签： leetcode 字符串

本文链接：https://blog.csdn.net/qq_40693171/article/details/109899072

版权

LeetCode 专栏收录该内容

55 篇文章 6 订阅

订阅专栏

原创公众号：bigsai 专注于Java、数据结构与算法，一起进大厂不迷路！
关注后回复进群即可加入力扣打卡群，欢迎划水。近期打卡：
LeetCode打卡 52八皇后Ⅱ&53最大子序和&54螺旋矩阵
 LeetCode 55跳跃游戏&56合并区间&57插入区间
 跟我打卡LeetCode 58最后一个单词长度&59螺旋矩阵Ⅱ&60排列序列
 跟我打卡LeetCode 61旋转链表&62不同路径&63不同路径 II

最小路径和

在这里插入图片描述

简单的动态规划，只能向右或者向下，所以可以使用动态规划动态的找到最小路径和，先对第一行和第一列特殊处理，然后顺序遍历数组的时候状态转移方程为：

dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];

其中dp[i][j]意为第i行第j列的最小路径和。
具体代码为：

public  int minPathSum(int[][] grid) {
       int m=grid.length;
        int n=grid[0].length;
        int dp[][]=new int[m][n];
        dp[0][0]=grid[0][0];
        //先初始化第0行和第0列
        for(int i=1;i<n;i++)
        {
            dp[0][i]=dp[0][i-1]+grid[0][i];
        }
        for(int j=1;j<m;j++)
        {
            dp[j][0]=dp[j-1][0]+grid[j][0];
        }
        //System.out.println(Arrays.deepToString(dp));
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];

    }

有效数字

验证给定的字符串是否可以解释为十进制数字。

例如:

"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true
" -90e3   " => true
" 1e" => false
"e3" => false
" 6e-1" => true
" 99e2.5 " => false
"53.5e93" => true
" --6 " => false
"-+3" => false
"95a54e53" => false

说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。
这里给出一份可能存在于有效十进制数字中的字符列表：

数字 0-9
指数 - "e"
正/负号 - "+"/"-"
小数点 - "."
当然，在输入中，这些字符的上下文也很重要。

更新于 2015-02-10:
C++函数的形式已经更新了。如果你仍然看见你的函数接收 const char * 类型的参数，请点击重载按钮重置你的代码。

分析
这题其实挺麻烦的，我也是根据样例不停的测试然后才最终得到正确的结果。这些数字和符号有一定的规律和要求。 我的分析就是将数字分成三块 e前，e，e后。而每个数字可能是符号数字小数点等组成需要满足一定规律。符号可以没有，但是数字必须有！ 具体可以参考这张图：

在这里插入图片描述

实现代码为：

public boolean isNumber(String s) {
          s=s.trim();
          char str[]=s.toCharArray();
      
	    boolean smallpoint=false;//小数点
        boolean ise=false;//是否遇到e
        int localindex=0;//当前数字指标
        // 整体思路            左侧部分              e     右侧部分
        for(int i=0;i<str.length;i++)
        {
        	if(localindex==0&&(str[i]=='+'||str[i]=='-'))// + -号必须出现在前面 也就是localindex=0
        	{
        		if(smallpoint)return false; //小数点后不能有+- 例如0.+3
        	    continue;//否则继续
        	}
        	else if (str[i]=='.') {
				if(smallpoint||ise)//当有小数点或者在e后面 不能3.12.5 也不能1e2.3
					return false;
				else {
					smallpoint=true;//否则将标记出现过小数点
				}
			}
        	else if ((str[i]=='e'||str[i]=='E')&&localindex>0) {//遇到e
				if(ise)return false;//如果已经有e 那么返回false 不能 4e5e
				else {
					smallpoint=false;//否则说明正常，开始统计e右侧部分。e右侧部分开始重新统计
					ise=true;//标记e已经出现
					localindex=0;//数字编号
				}
			}
        	else if (str[i]>='0'&&str[i]<='9') {
				localindex++;
			}
        	else {
				return false;
			}
        }
        if (localindex>0) {
			return true;
		}
        else	        
        	return false;
   }

还有这种方法就是有限状态机（DFA）解决，具体解释看题解吧：

图片来源力扣题解

在这里插入图片描述

class Solution {
    public int make(char c) {
        switch(c) {
            case ' ': return 0;
            case '+':
            case '-': return 1;
            case '.': return 3;
            case 'e': return 4;
            default:
                if(c >= 48 && c <= 57) return 2;
        }
        return -1;
    }
    
    public boolean isNumber(String s) {
        int state = 0;
        int finals = 0b101101000;
        int[][] transfer = new int[][]{{ 0, 1, 6, 2,-1},
                                       {-1,-1, 6, 2,-1},
                                       {-1,-1, 3,-1,-1},
                                       { 8,-1, 3,-1, 4},
                                       {-1, 7, 5,-1,-1},
                                       { 8,-1, 5,-1,-1},
                                       { 8,-1, 6, 3, 4},
                                       {-1,-1, 5,-1,-1},
                                       { 8,-1,-1,-1,-1}};
        char[] ss = s.toCharArray();
        for(int i=0; i < ss.length; ++i) {
            int id = make(ss[i]);
            if (id < 0) return false;
            state = transfer[state][id];
            if (state < 0) return false;
        }
        return (finals & (1 << state)) > 0;
    }
}

作者：user8973
链接：https://leetcode-cn.com/problems/valid-number/solution/biao-qu-dong-fa-by-user8973/
来源：力扣（LeetCode）

加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：

输入：digits = [0]
输出：[1]

提示：

1 <= digits.length <= 100
0 <= digits[i] <= 9

分析：简单题，只需要本本分分模拟即可，将数组最后一位加一，如果产生进位一直向前判断是否还需要进位。有一个需要注意的地方就是如果结束第0位也需要进位那么需要重新创建数组扩容赋值返回。

实现代码：

class Solution {
    public int[] plusOne(int[] digits) {
         if(digits [digits.length-1]++==9)
            for(int i=digits.length-1;i>0;i--)
            {
                digits[i]=0;
                if(++digits[i-1]!=10)
                    break;
            }
        if(digits[0]==10)
        {
            int value[]=new int[digits.length+1];
            digits[0]=0;
            value[0]=1;
            System.arraycopy(digits,0,value,1,digits.length);
            return  value;
        }
        return digits;
    }
}