有效的数独

36 有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

    数字 1-9 在每一行只能出现一次。
    数字 1-9 在每一列只能出现一次。
    数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

分析：

可以使用 box_index = (row / 3) * 3 + columns / 3，其中 / 是整数除法。

    如何确保行 / 列 / 子数独中没有重复项？

    可以利用 value -> count 哈希映射来跟踪所有已经遇到的值。

现在，我们完成了这个算法的所有准备工作：

    遍历数独。
    检查看到每个单元格值是否已经在当前的行 / 列 / 子数独中出现过：
        如果出现重复，返回 false。
        如果没有，则保留此值以进行进一步跟踪。
    返回 true。

• 时间复杂度：O(1)O(1)O(1)，因为我们只对 81 个单元格进行了一次迭代。
• 空间复杂度：O(1)O(1)O(1)。

 

 

 

上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 '.' 表示。

import java.util.HashMap;
class Solution {
    public boolean isValidSudoku(char[][] board) {      
        Map<Character,Integer> []map1=new HashMap[9];
        Map<Character,Integer> []map2=new HashMap[9];
        Map<Character,Integer> []map3=new HashMap[9];
        for(int i=0;i<9;i++){   
                 map1[i]=new HashMap<>();
                 map2[i]=new HashMap<>();
                 map3[i]=new HashMap<>();
            
        }
         for(int i=0;i<9;i++){
              for(int j=0;j<9;j++){
                 if(board[i][j]!='.'){
                     int m=(i/3)*3+j/3;
                    if(!map1[i].containsKey(board[i][j])&&!map2[j].containsKey(board[i][j])
                    &&!map3[m].containsKey(board[i][j])){
                    map1[i].put(board[i][j],1);
                     map2[j].put(board[i][j],1);
                      map3[m].put(board[i][j],1);
                }else {
                    return false;
                }
                 }
              }
         }
        return true;
    }
}

3. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

这道题主要用到思路是：滑动窗口

什么是滑动窗口？

其实就是一个队列,比如例题中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，我们要移动这个队列！

如何移动？

我们只要把队列的左边的元素移出就行了，直到满足题目要求！

一直维持这样的队列，找出队列出现最长的长度时候，求出解！

时间复杂度：O(n)O(n)O(n)

package leetcode;
import java.util.Map;
import java.util.HashMap;

public class mostString {

    public static void main(String[] args) {
        String str="pwwkew";
        System.out.println(mostLength(str));
    }
    public static String mostLength(String s) {
        String m="";
        int ans=0;
        int n= s.length();
        Map<Character,Integer> map= new HashMap<>();
        for(int start=0,end=0;end<n;end++) {
            char alpha=s.charAt(end);
            if(map.containsKey(alpha)) {
                start=Math.max(map.get(alpha), start);
            }
            map.put(alpha, end+1);
            ans=Math.max(end-start+1, ans);
            if(ans==end-start+1) {
                 m=s.substring(start,end+1);
            }
        }
        return m;
    }
    

}

 

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int ans=0;
        int n=s.length();
        Map<Character,Integer> map=new HashMap<>();
        for(int start=0, end=0;end<n;end++){          
            char alpha=s.charAt(end);
            if(map.containsKey(alpha)){
                start=Math.max(map.get(alpha),start);
            }
            map.put(alpha,end+1);
            ans=Math.max(end-start+1,ans);
                    }
                     return ans;
    }
   
}

9. 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true

示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

方法：反转一半数字
思路：
映入脑海的第一个想法是将数字转换为字符串，并检查字符串是否为回文。但是，这需要额外的非常量空间来创建问题描述中所不允许的字符串。

第二个想法是将数字本身反转，然后将反转后的数字与原始数字进行比较，如果它们是相同的，那么这个数字就是回文。
但是，如果反转后的数字大于 int.MAX\text{int.MAX}int.MAX，我们将遇到整数溢出问题。

按照第二个想法，为了避免数字反转可能导致的溢出问题，为什么不考虑只反转 int\text{int}int 数字的一半？毕竟，如果该数字是回文，其后半部分反转后应该与原始数字的前半部分相同。

例如，输入 1221，我们可以将数字 “1221” 的后半部分从 “21” 反转为 “12”，并将其与前半部分 “12” 进行比较，因为二者相同，我们得知数字 1221 是回文。

让我们看看如何将这个想法转化为一个算法。

算法：
首先，我们应该处理一些临界情况。所有负数都不可能是回文，例如：-123 不是回文，因为 - 不等于 3。所以我们可以对所有负数返回 false。

现在，让我们来考虑如何反转后半部分的数字。
对于数字 1221，如果执行 1221 % 10，我们将得到最后一位数字 1，要得到倒数第二位数字，我们可以先通过除以 10 把最后一位数字从 1221 中移除，1221 / 10 = 122，再求出上一步结果除以 10 的余数，122 % 10 = 2，就可以得到倒数第二位数字。如果我们把最后一位数字乘以 10，再加上倒数第二位数字，1 * 10 + 2 = 12，就得到了我们想要的反转后的数字。如果继续这个过程，我们将得到更多位数的反转数字。

现在的问题是，我们如何知道反转数字的位数已经达到原始数字位数的一半？

我们将原始数字除以 10，然后给反转后的数字乘上 10，所以，当原始数字小于反转后的数字时，就意味着我们已经处理了一半位数的数字。

public class Solution {
    public bool IsPalindrome(int x) {
        // 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if(x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }

        int revertedNumber = 0;
        while(x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }

        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x == revertedNumber || x == revertedNumber/10;
    }
}

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"

复杂度分析

    时间复杂度：O(S)O(S)O(S)，S 是所有字符串中字符数量的总和。

    最坏的情况下，nnn 个字符串都是相同的。算法会将 S1S1S1 与其他字符串 [S2…Sn][S_2 \ldots S_n][S2​…Sn​] 都做一次比较。这样就会进行 SSS 次字符比较，其中 SSS 是输入数据中所有字符数量。

    空间复杂度：O(1)O(1)O(1)，我们只需要使用常数级别的额外空间。

public String longestCommonPrefix(String[] strs) {
   if (strs.length == 0) return "";
   String prefix = strs[0];
   for (int i = 1; i < strs.length; i++)
       while (strs[i].indexOf(prefix) != 0) {
           prefix = prefix.substring(0, prefix.length() - 1);
           if (prefix.isEmpty()) return "";
       }        
   return prefix;
}

11. 盛最多水的容器

给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2

 

 

 双指针：

复杂度分析：

    时间复杂度 O(N)O(N)O(N)，双指针遍历一次底边宽度 NNN 。
    空间复杂度 O(1)O(1)O(1)，指针使用常数额外空间。

class Solution {
    public int maxArea(int[] height) {
        int maxarea=0;
        int l=0;
        int r=height.length-1;
        while(l<r){
            maxarea=Math.max(maxarea,Math.min(height[l],height[r])*(r-l));
            if(height[l]<height[r])
            l++;
            else 
            r--;
        }
        return maxarea;
    }
}