首页 文章 精选 留言 我的

精选列表

搜索[leetcode],共438篇文章
优秀的个人博客,低调大师

leetCode 编程笔记

问:编写一个函数来查找字符串数组的最长公共前缀。如果不存在公共前缀,返回空字符串 “”。 示例输入:["flower", "flow", "flight"] 示例输出:"fl" 示例输入:["dog", "racecar", "car"] 示例输出:"" 解释:输入不存在公共前缀。 tips:所有的输入只包含小写字母 a-z 。 public class Solution { // 1. Method 1, start from the first one, compare prefix with next string, until end; // 2. Method 2, start from the first char, compare it with all string, and then the second char // I am using method 1 here public String longestCommonPrefix(String[] strs) { if (strs == null || strs.length == 0) { return ""; } String prefix = strs[0]; for(int i = 1; i < strs.length; i++) { int j = 0; while( j < strs[i].length() && j < prefix.length() && strs[i].charAt(j) == prefix.charAt(j)) { j++; } if( j == 0) { return ""; } prefix = prefix.substring(0, j); } return prefix; } } 有一个X x Y的网格,只能向右、向下移动,从(0, 0)走到(X - 1, Y - 1),中间某些位置有障碍物,打印一条路径(优化) 答:解题思路。 12.png 计算过程: 把底边和右边的每个格子标记为1 其余格子从右下角往右上角依次遍历 每个格子的值是其右边和下边格子值的和 遍历到右上角后求得最终结果 例如上图的结果为10。 这种解法依据的思路,由于每个格子只能向右或向下走,那么它的走法就由其右边格子的走法和下边格子的走法之和。而最下边和最右边的每个格子都只有唯一的走法。由此就能推导出其余格子的走法。 13.png tips:注意把握思想,把右下角右边和底部的边都设置为 1.之后向上推倒即可。最终结果是 10. 归并排序: //将有序数组a[]和b[]合并到c[]中 void MemeryArray(int a[], int n, int b[], int m, int c[]) { int i, j, k; i = j = k = 0; while (i < n && j < m) { if (a[i] < b[j]) c[k++] = a[i++]; else c[k++] = b[j++]; } // 当其中一个列表的所有数据都比另一个列表的所有数据小的时候,例如 i = n,j = 0; while (i < n) c[k++] = a[i++]; while (j < m) c[k++] = b[j++]; } tips: 解决了上面的合并有序数列问题,再来看归并排序,其的基本思路就是将数组分成二组A,B,如果这二组组内的数据都是有序的,那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了? 可以将A,B组各自再分成二组。依次类推,当分出来的小组只有一个数据时,可以认为这个小组组内已经达到了有序,然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列,再合并数列就完成了归并排序。 构建 Hash 表的时候(散列函数的设计) f( key ) = key mod p ( p ≤ m ) mod ... 使用除留余数法的一个经验是,若散列表表长为m,通常p为小于或等于表 如何合理选取p值 使用除留余数法的一个经验是,若散列表表长为m,通常p为小于或等于表长(最好接近m)的最小质数或不包含小于20质因子的合数。 这句话怎么理解呢?要不这样吧,我再举个例子:某散列表的长度为100,散列函数H(k)=k%P,则P通常情况下最好选择哪个呢?A、91 B、93 C、97 D、99 实践证明,当P取小于哈希表长的最大质数时,产生的哈希函数较好。我选97,因为它是离长度值最近的最大质数。 可以盛最多水的容器 解法:我们可以循环遍历所有的两天边的乘积,取最大的值。 01.png 编程试题:求数列的和 使用语言:JAVA 参考正解代码如下: import java.util.*; class Main{ public static void main(String args[]){ int m; double sum,n; Scanner sc = new Scanner(System.in); while(sc.hasNext()){ n=sc.nextInt(); m=sc.nextInt(); sum=0; for(int i=0;i<m;i++){ sum=sum+n; n=Math.sqrt(n); } System.out.printf("%.2f",sum); System.out.println(); } } } 使用语言:C++ 参考正解代码如下: #include <math.h> #include <stdio.h> int main() { int n; double x, s; while (~scanf("%lf%d", &x, &n)) { for(s = 0.0; n--; x = sqrt(x)) s += x; printf("%.2lf\n", s); } return 0; } 使用语言:C# 参考正解代码如下: using System; namespace myApp { class Program { public static void Main() { string line; string[] p; int m, n; double nn; while (!string.IsNullOrEmpty(line = Console.ReadLine())) { p = line.Split(' '); n = int.Parse(p[0]); m = int.Parse(p[1]); double sum = 0; nn = n; for (int i = 0; i < m; i++) { sum = sum + nn; nn = Math.Sqrt(nn); } Console.WriteLine(string.Format("{0:f}", sum)); } } } } 使用语言:JavaScript 参考正解代码如下: var m; var sum,n; var sc while(sc = read_line()){ var arr = sc.split(' '); n=parseInt(arr[0]); m=parseInt(arr[1]); sum=0; for(var i=0;i<m;i++){ sum=sum+n; n=Math.sqrt(n); } print(sum.toFixed(2)); } 注意上面的三个代码有几点注意: 一:JavaScript 的输入和输出为 sc = read——line() 输出:print(); 精确到后两位:sum.toFixed(2) 二:C / C++ 精确到两位小数为:printf("%.2lf\n", s); 三:Java编写程序的时候精确到小数点后两位的写法:System.out.printf("%.2f",sum); 水仙花的求解 编程试题:水仙花 使用语言:JAVA 参考正解代码如下: import java.util.Scanner; public class Main{ public static void main(String args[]){ Scanner reader=new Scanner(System.in); while(reader.hasNextInt()){ int m=reader.nextInt(); int n=reader.nextInt(); if(100<=m&&m<=n&&n<=999){ int j=0; for(int i=m;i<=n;i++) { int geWei,shiWei,baiWei; baiWei=i/100; shiWei=(i-baiWei*100)/10; geWei=i-baiWei*100-shiWei*10; if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei) {j=j+1; if(j>1){ System.out.print(" "+i); } else{ System.out.print(i); } } } if(j==0){ System.out.print("no"); } System.out.println(); } } } } 使用语言:C++ 参考正解代码如下: #include<stdio.h> int main(){ int m,n; while(scanf("%d%d",&m,&n)!=EOF){ int t=0; for(int i=m; i<=n; i++){ int a=i/100; int b=i%100/10; int c=i%10; if(i==a*a*a+b*b*b+c*c*c && t==0){ printf("%d ",i); t++; } else if(i==a*a*a+b*b*b+c*c*c && t==1){ printf("%d ",i); } } if(t!=0){ printf("\n"); } if(t==0){ printf("no\n"); } } return 0; } 使用语言:C# 参考正解代码如下: using System; namespace myApp { class Program { public static void Main() { string line; string[] p; int m, n; while ((line = Console.ReadLine()) != null) { p = line.Split(' '); n = int.Parse(p[1]); m = int.Parse(p[0]); var j=0; for(var i=m;i<=n;i++) { int geWei,shiWei,baiWei; baiWei = (i/100); shiWei = ((i-baiWei*100)/10); geWei = i-baiWei*100-shiWei*10; if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei) { j=j+1; if(j>1) { Console.Write(" "+i); } else { Console.Write(i); } } } if(j==0) { Console.Write("no"); } Console.Write("\r\n"); } } } } 使用语言:JavaScript 参考正解代码如下: var sc; while(sc = read_line()){ var arr = sc.split(' '); n=parseInt(arr[1]); m=parseInt(arr[0]); if(100<=m&&m<=n&&n<=999){ var out = []; var j=0; for(var i=m;i<=n;i++) { var geWei,shiWei,baiWei; baiWei=parseInt(i/100); shiWei=parseInt((i-baiWei*100)/10); geWei=i-baiWei*100-shiWei*10; if(i==geWei*geWei*geWei+shiWei*shiWei*shiWei+baiWei*baiWei*baiWei) { j=j+1; if(j>1){ out.push(" "+i); } else{ out.push(i); } } } if(j==0){ out.push("no"); } print(out.join('')); } }

优秀的个人博客,低调大师

LeetCode第38题:报数

题目 报数序列是一个整数序列,按照其中的整数的顺序进行报数,得到下一个数。其前五项如下: 1、12、113、214、12115、111221 1 被读作("一个一"), 即 11。11 被读作("两个一"), 即 21。 21 被读作("一个二", "一个一"), 即 1211。 给定一个正整数 n(1 ≤ n ≤ 30),输出报数序列的第 n 项。 注意:整数顺序将表示为一个字符串。 这个题有点奇葩,多读几遍就懂了 示例 1: 输入: 1 输出: "1" 示例 2: 输入: 4 输出: "1211" 代码 class Solution(object): def countAndSay(self, n): """ :type n: int :rtype: str """ d = '1' for i in range(n-1): tem = d[0] s = '' count = 0 for x in d: if tem == x: count += 1 continue s += str(count) + tem count = 1 tem = x s += str(count) + tem d = s return d 其实这个比较快。。。。。。 抄袭自:@lwl class Solution(object): def countAndSay(self, n): """ :type n: int :rtype: str """ di = { 1:"1", 2:"11", 3:"21", 4:"1211", 5:"111221", 6:"312211", 7:"13112221", 8:"1113213211", 9:"31131211131221", 10:"13211311123113112211", 11:"11131221133112132113212221", 12:"3113112221232112111312211312113211", 13:"1321132132111213122112311311222113111221131221", 14:"11131221131211131231121113112221121321132132211331222113112211", 15:"311311222113111231131112132112311321322112111312211312111322212311322113212221", 16:"132113213221133112132113311211131221121321131211132221123113112221131112311332111213211322211312113211", 17:"11131221131211132221232112111312212321123113112221121113122113111231133221121321132132211331121321231231121113122113322113111221131221", 18:"31131122211311123113321112131221123113112211121312211213211321322112311311222113311213212322211211131221131211132221232112111312111213111213211231131122212322211331222113112211", 19:"1321132132211331121321231231121113112221121321132122311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213122112311311123112111331121113122112132113213211121332212311322113212221", 20:"11131221131211132221232112111312111213111213211231132132211211131221131211221321123113213221123113112221131112311332211211131221131211132211121312211231131112311211232221121321132132211331121321231231121113112221121321133112132112312321123113112221121113122113121113123112112322111213211322211312113211", 21:"311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122211311122122111312211213211312111322211213211321322113311213212322211231131122211311123113223112111311222112132113311213211221121332211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221131112311311121321122112132231121113122113322113111221131221", 22:"132113213221133112132123123112111311222112132113311213211231232112311311222112111312211311123113322112132113213221133122112231131122211211131221131112311332211211131221131211132221232112111312111213322112132113213221133112132113221321123113213221121113122123211211131221222112112322211231131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122211211133112111311222112111312211312111322211213211321322113311213211331121113122122211211132213211231131122212322211331222113112211", 23:"111312211312111322212321121113121112131112132112311321322112111312212321121113122112131112131221121321132132211231131122211331121321232221121113122113121113222123112221221321132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322212321121113122123211231131122113221123113221113122112132113213211121332212311322113212221", 24:"3113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213213211221113122113121113222112132113213221232112111312111213322112132113213221133112132123123112111311222112132113311213211221121332211231131122211311123113321112131221123113112221132231131122211211131221131112311332211213211321223112111311222112132113212221132221222112112322211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211132221121311121312211213211312111322211213211321322113311213212322211231131122211311123113321112131221123113112211121312211213211321222113222112132113223113112221121113122113121113123112112322111213211322211312113211", 25:"132113213221133112132123123112111311222112132113311213211231232112311311222112111312211311123113322112132113212231121113112221121321132132211231232112311321322112311311222113111231133221121113122113121113221112131221123113111231121123222112132113213221133112132123123112111312111312212231131122211311123113322112111312211312111322111213122112311311123112112322211211131221131211132221232112111312111213111213211231132132211211131221232112111312212221121123222112132113213221133112132123123112111311222112132113213221132213211321322112311311222113311213212322211211131221131211221321123113213221121113122113121132211332113221122112133221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112212211131221121321131211132221123113112221131112311332211211133112111311222112111312211311123113322112111312211312111322212321121113121112133221121321132132211331121321231231121113112221121321132122311211131122211211131221131211322113322112111312211322132113213221123113112221131112311311121321122112132231121113122113322113111221131221", 26:"1113122113121113222123211211131211121311121321123113213221121113122123211211131221121311121312211213211321322112311311222113311213212322211211131221131211221321123113213221121113122113121113222112131112131221121321131211132221121321132132211331121321232221123113112221131112311322311211131122211213211331121321122112133221121113122113121113222123211211131211121311121321123113111231131122112213211321322113311213212322211231131122211311123113223112111311222112132113311213211221121332211231131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122113221122112133221121113122113121113222123211211131211121311121321123113213221121113122113121113222113221113122113121113222112132113213221232112111312111213322112311311222113111221221113122112132113121113222112311311222113111221132221231221132221222112112322211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331121321232221123123211231132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312111213111213211231132132211211131221131211221321123113213221123113112221131112211322212322211231131122211322111312211312111322211213211321322113311213211331121113122122211211132213211231131122212322211331222113112211", 27:"31131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122211211133112111311222112111312211312111322211213211321322123211211131211121332211231131122211311122122111312211213211312111322211231131122211311123113322112111331121113112221121113122113111231133221121113122113121113222123211211131211121332211213211321322113311213211322132112311321322112111312212321121113122122211211232221123113112221131112311332111213122112311311123112111331121113122112132113311213211321222122111312211312111322212321121113121112133221121321132132211331121321132213211231132132211211131221232112111312212221121123222112132113213221133112132123123112111311222112132113311213211231232112311311222112111312211311123113322112132113212231121113112221121321132122211322212221121123222112311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122211311123113322113223113112221131112311332211211131221131211132211121312211231131112311211232221121321132132211331221122311311222112111312211311123113322112132113213221133122211332111213112221133211322112211213322112111312211312111322212321121113121112131112132112311321322112111312212321121113122112131112131221121321132132211231131122211331121321232221121113122113121122132112311321322112111312211312111322211213111213122112132113121113222112132113213221133112132123222112311311222113111231132231121113112221121321133112132112211213322112111312211312111322212311222122132113213221123113112221133112132123222112111312211312111322212321121113121112133221121311121312211213211312111322211213211321322123211211131211121332211213211321322113311213212312311211131122211213211331121321122112133221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311222113111221221113122112132113121113222112132113213221133122211332111213322112132113213221132231131122211311123113322112111312211312111322212321121113122123211231131122113221123113221113122112132113213211121332212311322113212221", 28:"13211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331121321232221123123211231132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221232112111312211312113211223113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211322113321132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321322113311213212322211322132113213221133112132123222112311311222113111231132231121113112221121321133112132112211213322112111312211312111322212311222122132113213221123113112221133112132123222112111312211312111322212311322123123112111321322123122113222122211211232221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112212211131221121321131211132221123113112221131112311332211211133112111311222112111312211311123113322112111312211312111322212321121113121112133221121321132132211331121321132213211231132132211211131221232112111312212221121123222112311311222113111231133211121321321122111312211312111322211213211321322123211211131211121332211231131122211311123113321112131221123113111231121123222112111331121113112221121113122113111231133221121113122113121113221112131221123113111231121123222112111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321133112132112312321123113112221121113122113111231133221121321132132211331221122311311222112111312211311123113322112111312211312111322212311322123123112112322211211131221131211132221132213211321322113311213212322211231131122211311123113321112131221123113112211121312211213211321222113222112132113223113112221121113122113121113123112112322111213211322211312113211", 29:"11131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211132221121311121312211213211312111322211213211321322113311213212322211231131122211311123113223112111311222112132113311213211221121332211211131221131211132221231122212213211321322112311311222113311213212322211211131221131211132221232112111312111213322112131112131221121321131211132221121321132132212321121113121112133221121321132132211331121321231231121113112221121321133112132112211213322112311311222113111231133211121312211231131122211322311311222112111312211311123113322112132113212231121113112221121321132122211322212221121123222112111312211312111322212321121113121112131112132112311321322112111312212321121113122112131112131221121321132132211231131122111213122112311311222113111221131221221321132132211331121321231231121113112221121321133112132112211213322112311311222113111231133211121312211231131122211322311311222112111312211311123113322112132113212231121113112221121321132122211322212221121123222112311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122111213122112311311222112111331121113112221121113122113121113222112132113213221232112111312111213322112311311222113111221221113122112132113121113222112311311222113111221132221231221132221222112112322211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312111322212321121113121112133221132211131221131211132221232112111312111213322112132113213221133112132113221321123113213221121113122123211211131221222112112322211231131122211311123113321112132132112211131221131211132221121321132132212321121113121112133221123113112221131112311332111213211322111213111213211231131211132211121311222113321132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331121321232221123123211231132132211231131122211331121321232221123113112221131112311332111213122112311311123112112322211211131221131211132221232112111312211322111312211213211312111322211231131122111213122112311311221132211221121332211213211321322113311213212312311211131211131221223113112221131112311332211211131221131211132211121312211231131112311211232221121321132132211331121321231231121113112221121321133112132112211213322112312321123113213221123113112221133112132123222112311311222113111231132231121113112221121321133112132112211213322112311311222113111231133211121312211231131112311211133112111312211213211312111322211231131122111213122112311311221132211221121332211211131221131211132221232112111312111213111213211231132132211211131221232112111312211213111213122112132113213221123113112221133112132123222112111312211312111322212311222122132113213221123113112221133112132123222112311311222113111231133211121321132211121311121321122112133221123113112221131112311332211322111312211312111322212321121113121112133221121321132132211331121321231231121113112221121321132122311211131122211211131221131211322113322112111312211322132113213221123113112221131112311311121321122112132231121113122113322113111221131221", 30:"3113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112212211131221121321131211132221123113112221131112311332211211133112111311222112111312211311123113322112111312211312111322212321121113121112133221121321132132211331121321132213211231132132211211131221232112111312212221121123222112311311222113111231133211121321321122111312211312111322211213211321322123211211131211121332211231131122211311123113321112131221123113111231121123222112111331121113112221121113122113111231133221121113122113121113221112131221123113111231121123222112111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321132132211322132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211322113321132211221121332211231131122211311123113321112131221123113111231121113311211131221121321131211132221123113112211121312211231131122211211133112111311222112111312211312111322211213211321223112111311222112132113213221133122211311221122111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321132132211322132113213221123113112221133112132123222112111312211312112213211231132132211211131221131211322113321132211221121332211213211321322113311213212312311211131122211213211331121321123123211231131122211211131221131112311332211213211321223112111311222112132113213221123123211231132132211231131122211311123113322112111312211312111322111213122112311311123112112322211213211321322113312211223113112221121113122113111231133221121321132132211331222113321112131122211332113221122112133221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213122112311311123112112322211322311311222113111231133211121312211231131112311211232221121113122113121113222123211211131221132211131221121321131211132221123113112211121312211231131122113221122112133221121321132132211331121321231231121113121113122122311311222113111231133221121113122113121113221112131221123113111231121123222112132113213221133112132123123112111312211322311211133112111312211213211311123113223112111321322123122113222122211211232221121113122113121113222123211211131211121311121321123113213221121113122123211211131221121311121312211213211321322112311311222113311213212322211211131221131211221321123113213221121113122113121113222112131112131221121321131211132221121321132132211331121321232221123113112221131112311322311211131122211213211331121321122112133221121113122113121113222123112221221321132132211231131122211331121321232221121113122113121113222123211211131211121332211213111213122112132113121113222112132113213221232112111312111213322112132113213221133112132123123112111311222112132113311213211221121332211231131122211311123113321112131221123113112221132231131122211211131221131112311332211213211321223112111311222112132113212221132221222112112322211211131221131211132221232112111312111213111213211231131112311311221122132113213221133112132123222112311311222113111231132231121113112221121321133112132112211213322112111312211312111322212321121113121112131112132112311321322112111312212321121113122122211211232221121311121312211213211312111322211213211321322123211211131211121332211213211321322113311213211322132112311321322112111312212321121113122122211211232221121321132132211331121321231231121113112221121321133112132112312321123113112221121113122113111231133221121321132122311211131122211213211321222113222122211211232221123113112221131112311332111213122112311311123112111331121113122112132113121113222112311311221112131221123113112221121113311211131122211211131221131211132221121321132132212321121113121112133221123113112221131112311332111213213211221113122113121113222112132113213221232112111312111213322112132113213221133112132123123112111312211322311211133112111312212221121123222112132113213221133112132123222113223113112221131112311332111213122112311311123112112322211211131221131211132221232112111312111213111213211231132132211211131221131211221321123113213221123113112221131112211322212322211231131122211322111312211312111322211213211321322113311213211331121113122122211211132213211231131122212322211331222113112211", } return di[n] 本文链接:时光不写博客-报数

优秀的个人博客,低调大师

LeetCode 203:移除链表元素

删除链表中等于给定值 val 的所有节点。 Remove all elements from a linked list of integers that have value val. 示例: 输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5 解题思路: 两种方法,一种是迭代法,从第一个节点开始,遇到值相同的节点就将其删除。链表的删除操作是直接将删除节点的前一个节点指向删除节点的后一个节点即可。 第二种方法是递归,用递归从后向前遇到相同节点直接指向该节点的下一个节点的地址即可 迭代法: 由于链表删除操作的特殊性,如果要删除某个节点,必须要知道该删除节点的前一个节点地址才可完成删除操作。所以如果是从第一个节点开始判断,就要考虑到第一个节点是否为空节点、第一个节点是否就是该删除的的节点,删除头节点和非头节点的操作不一样,应单独实现删除操作。 如果原链表是这种形式:1->1->1->2 val=1 删除头节点后第二个节点置为头节点,但是第二个节点作为新的头节点依然需要删除,所以对头节点的操作应该是一个迭代过程。 另外一种方法就是新建一个虚拟节点,该虚拟节点下一个节点指向原链表头节点。这就无需考虑头节点是否为空、是否为待删除节点。如原链表为:1->1->1->2 val=1 ,新建一个虚拟节点 -1 作为头节点:-1->1->1->1->2 val=1 ,这时只需正常迭代删除即可,唯一要注意是返回节点不能是 head ,因为原链表的头节点如果是待删除节点,此时 head 节点已被删除并作为单独隔离出来的节点,并非链表内的一个节点。 Java: class Solution { public ListNode removeElements(ListNode head, int val) { ListNode newHead=new ListNode(-1);//新建虚拟节点 newHead.next=head;//虚拟节点作为原链表的头节点 ListNode cur = newHead;//遍历节点的指针 while (cur.next != null) { if (cur.next.val == val) { cur.next = cur.next.next;//删除操作 } else { cur = cur.next; } } return newHead.next;//返回的头节点应当是虚拟节点的下一个节点 } } Python3: class Solution: def removeElements(self, head: ListNode, val: int) -> ListNode: newHead = ListNode(-1) newHead.next = head cur = newHead while cur.next: if cur.next.val == val: cur.next = cur.next.next else: cur = cur.next return newHead.next 递归法: 递归方法解该题很简单,基线条件是遇到空节点(最后一个节点),递归时只需将传递参数节点的下一个节点作为新的参数传给递归函数即可: 如原链表为: 1->2->6->3->4->5->6, val = 6递归到空节点时最后一个递归函数返回null: 1->2->6->3->4->5->6->null回到上一层递归函数内此时 head.next 得到返回节点 null判断head为 6 删除,返回 head.next :1->2->6->3->4->5->null回到上一层递归函数此时 head.next 得到上一层返回节点依然为null判断head为 5 不删除,返回 head 为5:1->2->6->3->4->5->null回到上一层递归函数此时 head.next 得到上一层返回节点 5判断head为 4 不删除,返回 head 为4:1->2->6->3->4->5->null回到上一层递归函数此时 head.next 得到上一层返回节点 4.............. 直到回到第一个递归函数为止返回头节点结束。 Java: class Solution { public ListNode removeElements(ListNode head, int val) { if (head == null) return null;//基线条件 head.next = removeElements(head.next, val); if (head.val == val) { return head.next; } else { return head; } } } Python3: class Solution: def removeElements(self, head: ListNode, val: int) -> ListNode: if not head: return None head.next = self.removeElements(head.next, val) if head.val == val: return head.next else: return head 欢迎关注公众号一起学习:爱写Bug

优秀的个人博客,低调大师

LeetCode 867. 转置矩阵

题目 给定一个矩阵A,返回A的转置矩阵。 矩阵的转置是指将矩阵的主对角线翻转,交换矩阵的行索引与列索引。 示例 1: 输入:[[1,2,3],[4,5,6],[7,8,9]] 输出:[[1,4,7],[2,5,8],[3,6,9]] 示例 2: 输入:[[1,2,3],[4,5,6]] 输出:[[1,4],[2,5],[3,6]] 提示: 1 <= A.length<= 10001 <= A[0].length<= 1000 解题思路 class Solution: def transpose(self, A: [[int]]) -> [[int]]: res = [[0]*len(A) for i in range(len(A[0]))] for i in range(len(A)) : for j in range(len(A[i])): res[j][i] = A[i][j] return res

优秀的个人博客,低调大师

LeetCode 202: 快乐数 Happy Number

题目: 编写一个算法来判断一个数是不是 “快乐数”。 一个 “快乐数” 定义为:对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和,然后重复这个过程直到这个数变为 1,也可能是无限循环但始终变不到 1。如果可以变为 1,那么这个数就是快乐数。 Write an algorithm to determine if a number is "happy". A happy number is a number defined by the following process: Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers. 示例: 输入: 19 输出: true 解释: 1^2+ 9^2 = 82 8^2 + 2^2 = 68 6^2 + 8^2 = 100 1^2 + 0^2 + 0^2 = 1 解题思路: ​ 求每个位上的数字平方和,判断是否为 1,如果不为 1 则继续求该数每位的平方和。 如例题中求和:19 -> 82 -> 68 ->100 ->1 ->1 -> 1 ...... 不管是否为快乐数,该数最终必定进入一个循环。进入循环体的入口结点数字为 1,则该数为快乐数,否则不是快乐数。所以这道题就变成了 求有环链表的入环节点,这类似之前做过的另一道题:环形链表 2 同样,可以用 环形链表2 中的两种方法找到入环节点。 其实快乐数有一个已被证实的规律: ​ 不快乐数的数位平方和计算,最后都会进入 4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4 的循环体。 所以该题可以用递归来解,基线条件为 n < =4,满足基线体条件时,如果 n=1 则原数为快乐数,否则不是。 哈希表解题: Java: class Solution { public boolean isHappy(int n) { HashSet<Integer> hashSet = new LinkedHashSet<>();//哈希表记录数位平方和计算过程中的每个数 while (!hashSet.contains(n)) { hashSet.add(n); int sum = 0; while (n > 0) {//计算数位平方和 sum += (n % 10) * (n % 10); n /= 10; } n = sum;//n 为数位平方和 } return n == 1; } } Python: class Solution: def isHappy(self, n: int) -> bool: hashSet = set(1) #哈希集合内置1,可减少一次循环 while n not in hashSet: hashSet.add(n) n = sum(int(i)**2 for i in str(n)) #py可以直接转乘字符串遍历每个字符计算 return n == 1 递归解题: Java: class Solution { public boolean isHappy(int n) { if (n <= 4) return n == 1;//基线条件 int sum = n, tmp = 0; while (sum > 0) { tmp += (sum % 10) * (sum % 10); sum /= 10; } return isHappy(tmp);//递归调用 } } Python: class Solution: def isHappy(self, n: int) -> bool: return self.isHappy(sum(int(i)**2 for i in str(n))) if n > 4 else n == 1 #一行尾递归 快慢指针解题: Java: class Solution { public boolean isHappy(int n) { int slow = n, fast = helper(n); while (slow != fast) {//条件是快慢指针不相遇 slow = helper(slow); fast = helper(fast); fast = helper(fast);//快指针一次走两步(计算两次) } return slow == 1; } private int helper(int n) {//计算数位平方和辅助函数 int sum = 0; while (n > 0) { sum += (n % 10) * (n % 10); n /= 10; } return sum; } } Python class Solution: def isHappy(self, n: int) -> bool: slow, fast = n, self.helper(n) while slow != fast: slow = self.helper(slow) fast = self.helper(fast) fast = self.helper(fast) return slow == 1 def helper(self, n: int) -> int: return sum(int(i)**2 for i in str(n)) tips: ​ 就这道题而言,应该用快慢指针的方法。虽然不管是否为快乐数最终都会进入循环体,但是计算数位和的过程得到的每个数总量 理论上是可以非常大的,这就可能导致存储的哈希集合长度过大或递归深度太深,空间复杂度不可预测(不会超过整型范围)。快慢指针解题,每次值保存两个值,空间复杂度为 1。 欢迎关注微.信.公.众.号:爱写Bug

优秀的个人博客,低调大师

LeetCode 739:每日温度 Daily Temperatures

题目: 根据每日 气温 列表,请重新生成一个列表,对应位置的输入是你需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高,请在该位置用 0 来代替。 例如,给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73],你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。 Given a list of daily temperatures T, return a list such that, for each day in the input, tells you how many days you would have to wait until a warmer temperature. If there is no future day for which this is possible, put 0 instead. For example, given the list of temperatures T = [73, 74, 75, 71, 69, 72, 76, 73], your output should be [1, 1, 4, 2, 1, 1, 0, 0]. 提示:气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度,都是在 [30, 100] 范围内的整数。 Note: The length of temperatures will be in the range [1, 30000]. Each temperature will be an integer in the range [30, 100]. 解题思路: 最容易想到和理解的就是暴力穷举,两个指针,一个指针指向当前温度,第二指针向后遍历找到最近一个比当前温度高的温度,记录两个指针的索引差即可。可以说效率非常低了。 另一种方法是借助栈倒序遍历原数组,存入较高的温度的索引,也很容易理解,时间复杂度为 O(n)。其实现逻辑为: 原数组:[73, 74, 75, 71, 69, 72, 76, 73],指针 i 从末尾向前遍历,返回数组res=[0,0,0,0,0,0,0] 第一次遍历: i = 7, T[i] = 73, stack = [] 栈为空,res[7] = 0 ,73所在索引7入栈。stack = [7] 第二次遍历: i = 6, T[i] = 76, stack = [7] 栈顶对应索引7的温度T[7]=76,76>73,索引7出栈,此时栈为空,res[6] = 0。索引6入栈,stack = [6] 第三次遍历: i = 5, T[i] = 72, stack = [6] 栈顶对应索引6的温度T[6]=76,72<76,满足要求,当前索引5入栈。res[5] = 栈顶索引6 - 当前索引5 = 1, stack = [6,5] 第四次遍历: i = 4, T[i] = 69, stack = [6,5] 栈顶对应索引5的温度T[5]=72,69<72,满足要求,当前索引4入栈。res[4] = 栈顶索引5-当前索引4=1, stack = [6,5,4] 第五次遍历: i = 3, T[i] = 71, stack = [6,5,4] 栈顶对应索引的温度T[4]=69,71>69,栈顶元素出栈。stack = [6,5] 栈顶对应索引的温度T[5]=72,满足要求,当前索引3入栈。res[3] = 栈顶索引5-当前索引3=2, stack = [6,5,3] 第六次遍历: i = 2, T[i] = 75, stack = [6,5,3] 栈顶对应索引的温度T[3]=71,75>71,栈顶元素出栈。stack = [6,5] 栈顶对应索引的温度T[5]=72,75>72,栈顶元素出栈。stack = [6] 栈顶对应索引的温度T[6]=76,75<76,满足要求,当前索引2入栈。res[2] = 栈顶索引6-当前索引2=4, stack = [6,2] 第七次遍历: i = 1, T[i] = 74, stack = [6,2] 栈顶对应的温度T[2]=75,满足要求,当前索引1入栈。res[1] = 2-1=1, stack = [6,2,1] 第八次遍历: i = 0, T[i] = 73, stack = [6,2,1] 栈顶对应的温度T[1]=74,满足要求,当前索引0入栈。res[0] = 1-0=1, stack = [6,2,1,0] 遍历结束: res = [1,1,4,2,1,1,0,0] 这种方法下,栈存入索引对应的温度值始终按升序排列,当栈为空时,证明当前温度为 从该温度向后的所有温度里 最大的。 Java: class Solution { public int[] dailyTemperatures(int[] T) { int len=T.length; int[] res = new int[len]; Stack<Integer> stack = new Stack<>();//初始化栈 for (int i = len - 1; i >= 0; i--) { while (!stack.isEmpty() && T[stack.peek()] <= T[i]) { stack.pop(); } if (stack.isEmpty()) res[i] = 0; else res[i] = stack.peek() - i; stack.push(i); } return res; } } 事实上就这道题而言这并不是一个好方法,因为提示已经明确规定了数据范围: 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度,都是在 [30, 100] 范围内的整数。 最多30000个数据量,数据非常小,入栈出栈,获取栈顶元素,判断栈是否空,在数据量很少的情况下这些函数反复调用,相对就占用了很多运行时间,其最终评测运行总时间为 109 ms。那么如何优化? 由于所有数据值的范围均在30到100之间,那么意为着按升序排列温度的栈的大小 最大不会超过71(因为从30到100只有71个元素)。那就可以不用栈这个需要反复调用函数的数据结构。直接用长度为71的数组顺序存入索引即可,定义一个指针,索引减一代替出栈,索引加一并赋值代替入栈,索引是否溢出代替判断栈是否为空,无虚函数调用。 优化后: 总运行时间为 4ms,降低了105毫秒 class Solution { public int[] dailyTemperatures(int[] T) { int len = T.length; int[] res = new int[len], stack = new int[71]; int index = -1; for (int i = len - 1; i >= 0; i--) { while (index >= 0 && T[stack[index]] <= T[i]) { index--; } if(index >= 0) res[i] = stack[index] - i; stack[++index] = i; } return res; } } Python: python并没有队列、栈这种数据结构,因为数组就可以做到先进先出、后进先出等操作。 class Solution: def dailyTemperatures(self, T: List[int]) -> List[int]: tLen = len(T) stack = [] res = [0] * tLen for i in range(tLen - 1, -1, -1): while stack and T[i] >= T[stack[-1]]: stack.pop() if stack: res[i] = stack[-1] - i stack.append(i) return res 欢迎关注微.信公.众号 一起学习:爱写Bug

优秀的个人博客,低调大师

LeetCode第66题:加一

题目 给定一个由整数组成的非空数组所表示的非负整数,在该数的基础上加一。最高位数字存放在数组的首位, 数组中每个元素只存储一个数字。你可以假设除了整数 0 之外,这个整数不会以零开头。 示例 1:输入: [1,2,3]输出: [1,2,4]解释: 输入数组表示数字 123。 示例 2:输入: [4,3,2,1]输出: [4,3,2,2]解释: 输入数组表示数字 4321。 代码 class Solution: def plusOne(self, digits: List[int]) -> List[int]: str_l = str(digits).replace('[', '').replace(']', '').replace(', ', '') int_str_l = str(int(str_l) + 1) list_l = [int(i) for i in int_str_l] return list_l

优秀的个人博客,低调大师

LeetCode第28题:实现strStr()

题目 实现 strStr() 函数。给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在,则返回 -1。 示例 1: 输入: haystack = "hello", needle = "ll" 输出: 2 示例 2: 输入: haystack = "aaaaa", needle = "bba" 输出: -1 代码 class Solution(object): def strStr(self, haystack, needle): """ :type haystack: str :type needle: str :rtype: int """ if needle == "": return 0 if needle in haystack: return len(haystack.split(needle)[0]) else: return -1 本文链接:时光不写博客-实现strStr()

优秀的个人博客,低调大师

LeetCode第7题:整数反转

题目 给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。 示例1:输入: 123 输出: 321 示例2:输入: -123 输出: -321 示例3:输入: 120 输出: 21 注意: 假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。 代码 class Solution(object): def reverse(self, x): """ :type x: int :rtype: int """ if x < 0: str_x = str(x)[1:][::-1] x = -1 * int(str_x) if -2147483648 < x: return x return 0 x = int(str(x)[::-1]) if x < 2147483647: return x return 0 参考链接:时光不写博客-Reverse Integer

优秀的个人博客,低调大师

LeetCode第9题:回文数

题目 判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 示例1:输入: 121 输出: true 示例2:输入: -121 输出: false 解释: 从左向右读, 为 -121。 从右向左读, 为 121-。因此它不是一个回文数。 示例3:输入: 10 输出: false 解释: 从右向左读, 为 01。因此它不是一个回文数。 代码 class Solution(object): def isPalindrome(self, x): """ :type x: int :rtype: bool """ return str(x) == str(x)[::-1] 本文链接:时光不写博客-Palindrome Number

优秀的个人博客,低调大师

LeetCode 283:移动零 Move Zeroes

给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。 Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements. 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作,不能拷贝额外的数组。 尽量减少操作次数。 Note: You must do this in-place without making a copy of the array. Minimize the total number of operations. 解题思路: ​ 千万不要被题目局限了思维!题目让把所有0移到末尾,如果你的思路是遇零与末尾数字交换位置,然后还需要把非零数字排序,那么就被带偏了。 ​ 换个思路,把非 0 数字前移,不去管数字 0。 定义两个指针:指针 i 直接遍历数组遇到非 0 数字把该数字赋值给指针 j 所在的索引,索引 j 自增 1,i继续遍历。 这样遍历完之后,数组索引从0到 j 之间的数值即为所求得保持非零元素的相对顺序,而 j 之后的数值只需要全部赋值 0 即可。 Java: class Solution { public void moveZeroes(int[] nums) { int numsLen = nums.length; if (numsLen < 1) return;//数组长度小于一直接返回 int j = 0; for (int i = 0; i < numsLen; i++) {//遍历数组 if (nums[i] != 0) {//如果该数不为0 nums[j++] = nums[i];//赋值给索引j } } while (j < numsLen) nums[j++] = 0;//把从j到末尾所有数字赋值0 } } Python3: class Solution: def moveZeroes(self, nums: List[int]) -> None: """ Do not return anything, modify nums in-place instead. """ if len(nums) < 1: return j = 0 for num in nums: if num != 0: nums[j] = num j += 1 for i in range(j, len(nums)): nums[i] = 0 如果题目不限制在原数组上操作,用python一行可解决: nums = [i *for* i in nums *if* i != 0]+[i *for* i in nums *if* i == 0] 公众号: 爱写bug(ID:iCodeBugs)

优秀的个人博客,低调大师

LeetCode---Problem6 ZigZag Conversion

问题描述: 给定字符串s,按照给定的行数numRows,写成zigZag样式(Z字型样式/锯齿型样式),要求按照从上到下,从左到右的顺序依次遍历的字符形成的新字符串conversionString。例如String s = "PAYPALISHIRING",numRows = 3按照从上到下,从左到右的顺序conversionString = "PAHNAPLSIIGYIR"一张手绘图,简单明了呈现代码思路 代码 public String convert(String s, int numRows) { if(null==s || numRows<=0) { return null; } if(1==numRows || s.length()<=numRows) { return s; } char[] sb = new char[s.length()]; int pos = 0; //int count = numRows - 1; int i = 0; int index = i; int dis = 2*(numRows-1); //首行 while(index<s.length()) { sb[pos++] = s.charAt(index); index += dis; } //中间numRows-2行 for(i=1;i<numRows-1;i++) { index = i; //中间行相邻两个节点之间的距离有两个值,第一次是dis=2(numRows-(i+1)),因为三个节点构成一个完整的周期,在 //整个周期上的距离为s,s=2*numRows-1-1,所以第二次节点间距离为dis = s-dis,接着就又是dis dis = 2*(numRows-(i+1)); while(index<s.length()) { sb[pos++] = s.charAt(index); index += dis; dis = 2*(numRows-1) - dis; } } //此时i=count=numRows-1即尾行 index = i; dis = 2*(numRows-1); while(index<s.length()) { sb[pos++] = s.charAt(index); index += dis; } return new String(sb); } 这个是提交通过的代码题目本身并不难,之前一次提交的代码,执行超时了,现展示如下: public String convert(String s, int numRows) { if(null==s || numRows<=0) { return null; } if(s.length()<=numRows) { return s; } char[] sb = new char[s.length()]; int pos = 0; for(int i=0;i<numRows;i++) { int index = i; int dis = 2*(numRows-(i+1)); while(index<s.length()) { //首行和尾行遇到dis==0的情况下,不给数组赋值 if(0!=dis) { sb[pos++] = s.charAt(index); } //index移动 index = index + dis; //一个周期共有2*numRows-1个节点,总距离为2*numRows-1-1=2*(numRows-1) dis = 2*(numRows-1) - dis; } } return new String(sb); } 上面代码提交超时,究其原因代码 while(index<s.length()) { //首行和尾行遇到dis==0的情况下,不给数组赋值 if(0!=dis) { sb[pos++] = s.charAt(index); } //index移动 index = index + dis; //一个周期共有2*numRows-1个节点,总距离为2*numRows-1-1=2*(numRows-1) dis = 2*(numRows-1) - dis; } 其中的if语句每次都要进行判断,实际上只在首行和尾行中会遇到,代码看起来整起些,但执行的时间长了。查找算法中经常使用的哨兵就是为了减少数据比对的次数。当然了,上面的代码也没有判断1==numRows的情况。

优秀的个人博客,低调大师

Leetcode 54:Spiral Matrix 螺旋矩阵

54:Spiral Matrix 螺旋矩阵 Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order. 给定一个包含 m x n 个元素的矩阵(m 行, n 列),请按照顺时针螺旋顺序,返回矩阵中的所有元素。 Example 1: Input: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] Output: [1,2,3,6,9,8,7,4,5] Example 2: Input: [ [1, 2, 3, 4], [5, 6, 7, 8], [9,10,11,12] ] Output: [1,2,3,4,8,12,11,10,9,5,6,7] 解题思路: ​ 参考例二,观察索引改变方式:(0,0)--->(0,3)、(0,3)--->((2,3)--->(2,0)--->(1,0)--->(1,2) ​ 从(0,3)看,分别是:向下 横坐标自增1,到2;向左:纵坐标自减1 ,到0;向上横坐标自减1,到1;向右纵坐标自增1,到2 ​ 假如m*n的矩阵,从(0,m-1)开始,向下移动n-1次到达最下面,再向左m-1次,向上n-2次,向右m-2次,接着就是:向下n-3,向左m-3,向上n-4,向右m-4。每次转向m或n都会自减1。 ​ 这是我的思路,网上很多都是直接操作索引坐标,我觉得不是很好理解,因为超过一个螺旋的矩阵,每次都要更改参考坐标,不过两种方法本质差别不大 java: class Solution { public List<Integer> spiralOrder(int[][] matrix) { List nums=new ArrayList(); if (matrix.length==0||matrix[0].length==0)return nums ; int row=matrix.length-1,col=matrix[0].length-1,m=0,n=0,i=-1,tmp=0; while (row>=0&&col>=0){ switch (i++%4){ case 0: for (tmp=0;tmp<row;tmp++) nums.add(matrix[++m][n]);row-=1; break; case 1: for (tmp=0;tmp<col;tmp++) nums.add(matrix[m][--n]);col-=1; break; case 2: for (tmp=0;tmp<row;tmp++) nums.add(matrix[--m][n]);row-=1; break; case 3: for (tmp=0;tmp<col;tmp++) nums.add(matrix[m][++n]);col-=1; break; default: for (tmp=0;tmp<=col;tmp++) nums.add(matrix[m][n++]);tmp=0;n-=1; break; } } return nums; } } 注意点: ​ 先判断是否为空数组,判断条件顺序不能颠倒。因为如果 matrix.length==0 判断为true,则后面的 matrix[0].length==0 不会再判断,即返回空数组;但是matrix[0].length==0 在前时,如果输入数组为空,matrix[0] 会报错因为matrix并没有0号索引。 python3: class Solution: def spiralOrder(self, matrix: List[List[int]]) -> List[int]: if len(matrix)==0 or len(matrix[0])==0:return [] nums=[];m=0;n=0;row=len(matrix)-1;col=len(matrix[0])-1;flag=0; for n in range(col+1):nums.append(matrix[m][n]) while row>=0 and col>=0: if flag % 4 == 0: for i in range(row): m+=1 nums.append(matrix[m][n]) row -= 1 elif flag % 4==1: for i in range(col): n-=1 nums.append(matrix[m][n]) col -= 1 elif flag % 4 == 2: for i in range(row): m-=1 nums.append(matrix[m][n]) row -= 1 elif flag % 4 == 3: for i in range(col): n+=1 nums.append(matrix[m][n]) col -= 1 flag+=1 return nums 注意点: ​ python没有switch...case...语句。for循环可操作性很高,可以直接操作索引坐标改变遍历方式,不再赘述。

优秀的个人博客,低调大师

leetcode 28 c++ 实现strstr

暴力破解 从前往后找,结果超时了。。。。。。。。。。。。 int strStr(string haystack, string needle) { if (needle.length() == 0) return 0; if (needle.length() > haystack.length()) return -1; int n_index = 0; for (int i = 0; i < haystack.length(); i++) { if (n_index == needle.length()) { return i - needle.length(); } if (haystack[i] == needle[n_index]) { n_index++; } else { if (n_index > 0) { n_index = 0; n_index = 0; //从上一段重合的第二个字符开始找,不然第一段和第二段重合的会让你丢失第一段中后面的元素 i = i - needle.length() + 1; } } } if (n_index < needle.length()) return -1; else if (n_index == needle.length()) return haystack.length() - needle.length(); } 目测输在了每次我比较失败之后都会让 i 回到开始相同的点的后一个位置。来一个复杂度为O(n)的解法。 1、每次比较之前,判断余下的串的长度是否超过子串余下的串的长度 2、两个同步比较,使用continue跳出循环,降低时间复杂度 class Solution { public: int strStr(string haystack, string needle) { if(needle.size()==0) return 0; for(int i=0;i<haystack.size();i++){ if(i+needle.size()-1>=haystack.size()) return -1; int flag=1; for(int j=0;j<needle.size();j++){ if (haystack[i+j]==needle[j]) continue; flag=0; } if (flag==1) return i; } return -1; } };

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

用户登录
用户注册