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

原创公众号：​​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/

加一

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

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

你可以假设除了整数 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;
    }
}

原创不易，bigsai请你帮两件事帮忙一下:

1. 点赞、在看、分享支持一下， 您的肯定是我创作的源源动力。
2. 微信搜索「bigsai」，关注我的公众号

记得关注、咱们下次再见！