パーク値下げのブログには、問題の解決策の詳細を吸うhttps://github.com/TangliziGit/leetcode/blob/master/solution/11-20.md

Leetcodeソリューション11〜20

マーク：
@：ハード直接解を得るために
％を：必要性の最適化

良い質問

ほとんどの水で%%% 11コンテナ[中]
%%%%% 15 3Sum [中]
%%% 16 3Sum一番近い[中]
％18 4Sum [中]

概要

初期化ストリーム：Stream.of（）、Stream.iterate（0、X-> X + 1）.limit（MAX）
マップ：mapToInt（X - > ...）、...
フィルター：フィルター（X - > ...）
エンディング：削減（整数::分）、FindFirstの（）
プロセス：getAsInt（）、orElse（）
両側に介在原理ソート
X + Y = Zを提供するステップと、
IF（Z>タール）Y < - ; X-ELSE>;
効果：O（N）x + yに等しい2元を見つける== Z（x == Zを見つけることに等しいモノ）半分
HashSetの、HashMapのは、深刻な取るn回はO（1）300ミリ秒を過ごします
配列ソート：は、Arrays.sort（NUMS）
LinkedListのメソッド：追加
初期化リスト：は、Arrays.asList（X、X、X、...）
スタックの使用方法：プッシュ（）、PEEK（）、ポップ（）、のisEmpty（）
リストに[] int型：

  Arrays.sort(arr);
  Arrays.stream(arr).boxed().collect(Collectors.toList());

ほとんどの水で11コンテナ[中]

ほとんどの水で%%% 11コンテナ[中]

考え

O(n^2)
次いで、最大O（nlogn）を取って、計算を逆、後部から前方フェンウィックツリーは、最大高さ（カバー）を更新し、横断するのに使用します
バイナリ検索ツリーのO（nlogn）
ダブルポインタ、O（N）の両側がクランプ
最初の[I、J]の溶液を考慮し、我々はこの範囲内の溶液の最大値を決定する必要がある
範囲をより溶液を作るために減少されるとき、唯一の利点は、壁の高さである
各更新よう貪欲な最高の保護壁をする場合、
のみ説明されています...

点数

ノー

コード

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

ローマへの12の整数[中]

ローマ[中]に## 12.整数###思路水题、注意题意###要点无###代码 `Javaクラスソリューション{プライベート静的文字列のANS [] =新しいString [（INT）4E3 ]; プライベート静的整数[]の値= {1、4、5、9、10、40、50、90、100、400、500、900、1000年}。プライベート静的な文字列[]はexpr = { "I"、 "IV"、 "V"、 "IX"、 "X"、 "XL"、 "L"、 "XC"、 "C"、 "CD"、「D 」、 "CM"、 "M"}。パブリック文字列intToRoman（INT NUM）{リターン解く（NUM、value.length-1）。}パブリック文字列解決（整数nは、INT PTR）{IF（PTR == - 1） "戻ります"。（もし！ANS [N] = null）の戻りANS [N]; ANS [N] =リピート（式exprの【のPTR]、N /値[PTR]）+（N％値[PTR]を、PTR-1）を解きます。ANS [N]を返します。}パブリック文字列の繰り返し（文字列s、int型N）{（新しいCHAR [N]）新しい文字列を返す置き換える（ "\ 0"、S）。}} `` `

整数へ13.ローマ[簡単]

考え

水题, 注意题意

点数

ノー

コード

class Solution {
    private static Map<Character, Integer> map=new HashMap();
    
    static{
        map.put('I', 1);
        map.put('V', 5);
        map.put('X', 10);
        map.put('L', 50);
        map.put('C', 100);
        map.put('D', 500);
        map.put('M', 1000);
    };
    
    public int romanToInt(String s) {
        int ans=0, len=s.length();
        for (int i=0; i<len; i++)
            if (i+1<len && map.get(s.charAt(i))<map.get(s.charAt(i+1)))
                ans-=map.get(s.charAt(i));
            else 
                ans+=map.get(s.charAt(i));
        return ans;
    }
}

14.最長共通接頭辞[簡単]

考え

水問題は、
単にストリームを書き込みます

点数

初期化ストリーム：Stream.of（）、Stream.iterate（0、X-> X + 1）.limit（MAX）
マップ：mapToInt（X - > ...）、...
フィルター：フィルター（X - > ...）
エンディング：削減（整数::分）、FindFirstの（）
プロセス：getAsInt（）、orElse（）

コード

// Stream version
// 47ms, 38MB
class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs==null || strs.length==0) return "";
        int minlen=Stream.of(strs)
            .mapToInt(x -> x.length())
            .reduce(Integer::min)
            .getAsInt();
        int idx=Stream.iterate(0, x -> x+1).limit(0+minlen)
            .filter(x -> check(strs, x))
            .findFirst()
            .orElse(minlen);
        
        return strs[0].substring(0, idx);
    }
    
    public boolean check(String[] strs, int idx){
        return Stream.of(strs)
            .anyMatch(x -> x.charAt(idx)!=strs[0].charAt(idx));
    }
}

// Original
// 4ms, 39MB
class OriginalSolution {
    public String longestCommonPrefix(String[] strs) {
        if (strs==null || strs.length==0) return "";
        int idx=0, minlen=strs[0].length();
        for (String str: strs)
            minlen=Math.min(minlen, str.length());
        for (;idx<minlen; idx++)
            if (check(strs, idx)) break;
        return strs[0].substring(0, idx);
    }
    
    public boolean check(String[] strs, int idx){
        for (String str: strs)
            if (str.charAt(idx)!=strs[0].charAt(idx))
                return true;
        return false;
    }
}

15. 3Sum [中]

## %%%%% 15 3Sum [中] ###のアイデア1はO（n ^ 3）2 O（N ^ 2logn）^ 2 + binarySearch 3はO（n ^ 2 + nlogn + nの）大きな定数で：二つ取得した地図、その後、最後に小さな定数と重量4はO（n ^ 2 + nlogn + 2N）を横断：並べ替え、マップ要素がインデックスに対応している、繰り返す場合に撮影最後に、^ 2検索、挿入HashSetの5 O小さい定数（N ^ 2）：xについて：Y + Zを見つけるために、両側に挟ま== - X ###ポイント1 **ソートZを介在原理の両側に配置され= X + Y（Z>タール）yの場合< - ;他X->;効果：O（N）x + yに等しい2元を見つける== Z 2 HashSetの（X == Z等しい半分を見つけるモノ）、HashMapのは、深刻な取るn回O（1）300msのを費やして###コードはO（n ^ 3）バージョン `` `Javaクラスのソリューション{公共一覧 > threeSum（INT [] NUMS）{LinkedListの > ans=new LinkedList(); Arrays.sort(nums); for (int i=0; i -nums[i]) r--; else l++; } } return ans; } } ``` O(n^2+nlogn+n) with a small constant ```java class Solution{ public List > threeSum(int[] nums) { Map map=new HashMap(); Set > set=new HashSet(); LinkedList > ans=new LinkedList(); Arrays.sort(nums); // if duplicated, use the last one for (int i=0; i > threeSum(int[] nums) { Map > map=new HashMap(); Set > set=new HashSet(); ArrayList > ans=new ArrayList(); Arrays.sort(nums); for (int i=0; i ()); // O(1) List list=map.get(sum); // O(1) list.add(new Pair(i, j)); // O(1)? } } for (int i=0; i pair.y && I = pair.x && I = pair.y）{set.add（は、Arrays.asList（NUMS [pair.x]、NUMS [pair.y]、NUMS [I]））！。}}（一覧についてリスト：セット）ans.add（リスト）; ANSを返します。}静的クラス対{最終int型X、Y。対（int型のx、int型のY）{this.x = xと; this.y = Y。}}} `` `

16. 3Sum最寄りの[中]

%%% 16 3Sum最寄りの[中]

考え

O(n^3)
O（N ^ 2logn）二分
これらの3つの質問が二重ポインタであるため、O（N ^ 2）二重ポインタ、近年求めクリップの両側には、ビットが使用されます

点数

配列ソート：は、Arrays.sort（NUMS）

コード

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int ans=nums[0]+nums[1]+nums[2];
        Arrays.sort(nums);
        for (int i=0; i<nums.length; i++){
            int l=i+1, r=nums.length-1;
            while (l<r){
                int sum=nums[i]+nums[l]+nums[r];
                if (Math.abs(sum-target)<Math.abs(ans-target))
                    ans=sum;
                if (sum<target) l++;
                else r--;
            }
        }return ans;
    }
}

電話番号の17文字の組み合わせ[中]

考え

再帰的な水問題、

点数

LinkedListのメソッド：追加
初期化リスト：は、Arrays.asList（X、X、X、...）

コード

class Solution {
    private String template="abcdefghijklmnopqrstuvwxyz";
    
    public List<String> letterCombinations(String digits) {
        if (digits.equals("")) return new ArrayList<String>();
        return solve(digits, 0);
    }
    
    private List<String> solve(String digits, int ptr){
        if (ptr==digits.length()) return Arrays.asList("");
        List<String> tmp=solve(digits, ptr+1), ans=new LinkedList();
        int num=digits.charAt(ptr)-'2', n=(num+2==9||num+2==7)?4:3;
        int offset=(num+2==9||num+2==8)?1:0;
        for (String str: tmp){
            for (int i=offset; i<n+offset; i++)
                ans.add(template.charAt(i+num*3)+str);
        }return ans;
    }
}

18 4Sum [中]

##％18 4Sum [中] ###のアイデア1はO（n ^ 2 + nlogn）大きな定数マップが最適化2 O（N ^ 3）を設定+：二重ポインタ2 ^ため、クリップの両側1. intは[]のリストを表示する###ポイントのダブルポインタについて考える主なソリューション： `` `javaのは、Arrays.sort（ARR）。Arrays.stream（ARR））（.boxed収集（Collectors.toList（））。`` `###代码` `` Javaクラスのソリューション{公共一覧 > fourSum（INT [] NUMS、INT対象）{int型N = nums.length、サイズ= 0。INT []予備=新しいINT [N×（N-1）/ 2]。INT [] POS =新しいINT [N×（N-1）/ 2]。地図 >マップ=新しいHashMapの（）。セット >セット=新しいHashSetの（）。LinkedListの > ANS =新しいLinkedListの（）。私は、（私は0 = int型のためにリスト：セット）ans.add（リスト）; ANSを返します。}} `` `

19.リストの最後に[中]からn番目のノードを削除

考え

水問題の
最適化：
。ポインタ要素を削除した後、ランキングの終了後、ポインタから、後のポインタの最初のn個の要素に行くことができます
が、複雑さの度合いが改善されないが、一部の人々は、これは非常にあると言います最適化の良い、私は単にナンセンスをよく言います

点数

ノー

コード

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int len=0;
        ListNode tmp=head;
        
        while (tmp!=null){
            len++;
            tmp=tmp.next;
        }

        if (n==len) return head.next;
        
        tmp=head;
        for (int i=0; i<len-n-1; i++)
            tmp=tmp.next;
        tmp.next=tmp.next.next;
        
        return head;
    }
}

20.有効括弧[簡単]

考え

水問題、スタック

点数

スタックの使用方法：プッシュ（）、PEEK（）、ポップ（）、のisEmpty（）

コード

class Solution {
    private static Map<Character, Character> map=new HashMap();
    static{
        map.put('(', ')');
        map.put('{', '}');
        map.put('[', ']');
    }
    
    public boolean isValid(String s) {
        Stack<Character> sta=new Stack();
        int len=s.length();
        
        for (int i=0; i<len; i++){
            if (map.containsKey(s.charAt(i))) sta.push(s.charAt(i));
            else{
                if (!sta.isEmpty() && s.charAt(i)==map.get(sta.peek())) sta.pop();
                else return false;
            }
        }
        
        if (sta.isEmpty())
            return true;
        return false;
    }
}

問題レコード11-20へ[Leetcode]ソリューション