Kean’s Blog

Quick Sort

2018-08-02T00:00:00+00:00

#include <type_traits>
#include <iostream>
#include <vector>
#include <array>
#include <utility>
#include <list>
#include <forward_list>


template <typename RandomIt, typename  Compare=std::less<typename std::iterator_traits<RandomIt>::value_type> >
void quicksort(RandomIt first, RandomIt last, const Compare &comp = Compare()){
    if(first + 1 >= last)
        return;
    decltype((*first)) pivot = *first;
//    RandomIt ptr = first, now = first;
//    for(;now != last; ++now)
//        if(comp(*now, pivot))
//            std::swap(*(++ptr), *now);
//    std::swap(*first, *ptr);
//    quicksort(first, ptr, comp);
//    quicksort(ptr + 1, last, comp);

    RandomIt left = first, right = last;
    while(left < right){
        while(comp(pivot,*(--right)));
        while(left < right && comp(*(++left), pivot));
        //if(left < right)
            std::swap(*left, *right);
    }
    std::swap(*left, *first);
    quicksort(first, left, comp);
    quicksort(left + 1, last, comp);
}

/*
template <typename RandomIt>
void msort(RandomIt first, RandomIt last){
    using T = typename std::remove_reference<decltype(*first)>::type;
    quicksort<RandomIt, std::less<T>>(first, last, std::less<T>());
};
*/



template <typename T>
struct LinkNode {
    T value;
    LinkNode<T> * next;
    LinkNode():next(nullptr), value(){}
    LinkNode(const T & val, LinkNode<T> * lk):next(lk), value(val){}
};

template <typename T>
LinkNode<T> * __link_sort(LinkNode<T> * &first){
    if(first == nullptr || first->next == nullptr){
        return first;
    }
    LinkNode<T> *ptr = first->next, *tmp, *left = nullptr, *right = nullptr, *left_last=nullptr, *right_last=nullptr;
    while(ptr){
        tmp = ptr;
        ptr = ptr->next;
        if(tmp->value < first->value){
            tmp->next = left;
            left = tmp;
        }
        else{
            tmp->next = right;
            right = tmp;
        }
    }
    left_last = __link_sort(left);
    right_last = __link_sort(right);
    if(left_last != nullptr)
        left_last->next = first;
    else
        left = first;
    first->next = right;
    if(right == nullptr)
        right_last = first;
    first = left;
    return right_last;
}


template <typename T>
void link_sort(T & head){
    __link_sort(head);
}

template <typename T>
LinkNode<T> * __link_msort(LinkNode<T> *&head, std::size_t sz){
    if(sz <=  1){
        return head;
    }
    std::size_t left_sz = sz / 2, right_sz = sz - left_sz;
    LinkNode<T> new_head, * ptr = &new_head, * left = head;
    LinkNode<T> * left_last = __link_msort(left, left_sz);
    LinkNode<T> * right = left_last->next;
    LinkNode<T> * right_last = __link_msort(right, right_sz);
    LinkNode<T> * end_next = right_last->next;
    while(left_sz && right_sz){
        if(left->value < right->value) {
            ptr = ptr->next = left;
            left = left->next;
            left_sz--;
        }else{
            ptr = ptr->next = right;
            right = right->next;
            right_sz--;
        }
    }
    if(right_sz)
        left = right, left_last = right_last;
    if(left_sz || right_sz){
        ptr->next = left;
        ptr = left_last;
    }
    ptr->next = end_next;
    head = new_head.next;
    return ptr;
}

template <typename T>
void link_msort(T & head, std::size_t sz){
    __link_msort(head, sz);
}

template<typename T>
LinkNode<T> * __quick_sort(LinkNode<T> * &first){
    if(first == nullptr || first->next == nullptr)
        return first;
    LinkNode<T> lower, upper, *left = & lower, *right = & upper, * pov = first;
    first = first->next;
    while(first){
        if(pov->value < first->value){
            right->next = first;
            right = first;
        }
        else{
            left->next = first;
            left = first;
        }
        first = first->next;
    }
    left->next = right->next = nullptr;
    left = __quick_sort(lower.next);
    right = __quick_sort(upper.next);
    if(left == nullptr)
        left = &lower;
    left->next = pov;
    first = lower.next;
    pov->next = upper.next;
    if(right == nullptr)
        right = pov;
    return right;
}

template <typename T>
void list_qsort(T & head){
    __link_sort(head);
}

template <typename T>
LinkNode<T> * make_list(const std::vector<T> & values){
    LinkNode<T> head, * tmp = nullptr;
    for(const T & val:values){
        tmp = new LinkNode<T>(val, head.next);
        head.next = tmp;
    }
    return tmp;
}

template <typename T>
void print(LinkNode<T> * head){
    while(head){
        std::cout<<head->value << " ";
        head = head->next;
    }
    std::cout<<std::endl;
}

int testmsort(){
    test_vector();
    std::forward_list<int> ls;
    std::list<int> lst;
    ls.sort();
    lst.sort();
    std::vector<int> vec ={3,2,1,4,5,1,2,3,4,5,6,7,8,9,10};
    //std::vector<int> vec ={2,4,3,4};
    LinkNode<int> * first = make_list(vec), *last=nullptr;
    print(first);
    //link_msort(first, vec.size() - 6);
    /*  */

    link_sort(first);
//    link_qsort(first);
    print(first);
    return 0;
}

int __textmsort = testmsort();
int main(){
    return 0;
}

堆排序以及优先队列

2018-08-02T00:00:00+00:00

#include <iostream>

using std::swap;
template<typename T>
void heap_up(T & container, int cnt, int pos = 0){
    if(pos == 0)
        pos = cnt - 1;
    while(pos > 0 && container[pos] > container[(pos -1)/2]){
        swap(container[pos], container[(pos-1)/2]);
        pos = (pos - 1) / 2;
    }
}

template<typename T>
void heap_down(T & container, int cnt, int pos = 0){
    while(true){
        int left = pos * 2 + 1, right = pos * 2 + 2, index = pos;
        if(left < cnt && container[index] < container[left])
            index = left;
        if(right < cnt && container[index] < container[right])
            index = right;
        if(index == pos) break;
        swap(container[pos], container[index]);
        pos = index;
    }
}
template<typename T, typename V>
V heap_pop(T container, int cnt){
    swap(container[0], container[cnt -1]);
    heap_down(container, cnt -1);
    return container[cnt -1];
}
template<typename T, typename V>
int heap_push(T & container, int cnt, const V & value){
    container[cnt] = value;
    heap_up(container, cnt+1);
    return cnt + 1;
}
template<typename T>
void heap_build(T & container, int cnt){
    for(int root = (cnt - 2)/2; root >= 0; --root)
        heap_down(container, cnt, root);
}
template<typename T>
void heap_sort(T & container, int cnt){
    heap_build(container, cnt);
    //std::for_each(container.begin(), container.end(), [](const int & a){std::cout << a << " ";}); std::cout<<std::endl;
    for(int i = cnt - 1; i > 0; i--){
        std::swap(container[0], container[i]);
        heap_down(container, i, 0);
    }
}
#include <vector>
// #include <initializer_list>
template <typename T, typename Comp=std::less<T> >
class Heap{
    std::vector<T> datas;
    Comp comp;
    void build();
    void up(int pos);
    void down(int pos);
public:
    explicit Heap(const Comp & cmp=Comp()):comp(cmp){
        //std::cout<<"0 default construct" <<std::endl;
    }
    explicit Heap(const std::vector<T> & vec, const Comp & cmp=Comp()):datas(vec), comp(cmp){
        build();
        //std::cout<<"1 vector construct"<<std::endl;
    }
    explicit Heap(std::vector<T> && vec, const Comp & cmp=Comp()) noexcept :datas(vec), comp(cmp) {
        build();
        //std::cout<<"2 vector move construct"<<std::endl;
        // can be called as Heap<int> h({1,2,2}); without explicit
    }
    Heap(std::initializer_list<T> ilist, const Comp & cmp=Comp()):datas(ilist.begin(),ilist.end()), comp(cmp){
        build();
        //std::cout<<"3 list construct"<<std::endl;
        // can be called as Heap<int> a = {1,2,3}, b({2,3,4}), c{1,2,3,4};
    }
    template <typename Input>
    Heap(Input first, Input last, const Comp & cmp=Comp()):datas(first, last), comp(cmp){
        build();
        //std::cout<<"4 range construct" << std::endl;
    }
    Heap(Heap && h) noexcept :datas(std::move(h.datas)), comp(h.comp){ // 1
        //std::cout<<"5 move copy construct"<<std::endl;
        // can be called as Heap<int> h(std::move(hx)), h2 = std::move(hn);
    }
    Heap(const Heap & h):datas(h.datas), comp(h.comp){ // 2
        //std::cout<<"6 copy construct" << std::endl;
        // can be called as Heap<int> h(hx), h2 = hn;
    }
    Heap & operator = (const Heap & h){  // 3
        //std::cout<<"7 assignment copy" << std::endl;
        this->datas = h.datas;
        return *this;
        // be called as Heap<int> h1, h2; h1 = h2;
    }

    Heap & operator = (Heap && h) noexcept { // 4
        //std::cout<<"8 move assignment copy" << std::endl;
        this->datas = move(h.datas);
        return *this;
        // be called as Heap<int> h1, h2; h1 = std::move(h2); h2 = Heap<int>{};
    }
    ~Heap(){
        //std::cout<<"destruct Heap\n";
    }; // 5
    T top();
    void push(const T & v);
    void pop();
    bool empty();
    template <typename ... V> void emplace(V ... args){
        datas.emplace_back(args...);
        Heap<T, Comp>::up((int)datas.size() - 1);
    }
};

template <typename T, typename Comp>
void Heap<T, Comp>::up(int pos){
    while(pos > 0 && comp(datas[(pos-1)/2], datas[pos]))
    {
        std::swap(datas[pos], datas[(pos - 1)/2]);
        pos = (pos - 1) / 2;
    }
}

template <typename T, typename Comp>
void Heap<T, Comp>::down(int pos){
    while(true){
        int left = pos * 2 + 1, right = pos * 2 + 2, maxi = pos;
        if(left < datas.size() && comp(datas[maxi], datas[left]))
            maxi = left;
        if(right < datas.size() && comp(datas[maxi], datas[right]))
            maxi = right;
        if(maxi == pos) break;
        std::swap(datas[pos], datas[maxi]);
        pos = maxi;
    }
}

template <typename T, typename Comp>
T Heap<T, Comp>::top(){
    return datas[0];
}

template <typename T, typename Comp>
void Heap<T, Comp>::pop(){
    datas[0] = datas.back();
    datas.pop_back();
    Heap<T, Comp>::down(0);
}

template <typename T, typename Comp>
void Heap<T, Comp>::push(const T & v){
    datas.push_back(v);
    Heap<T, Comp>::up((int)datas.size() - 1);
}

template <typename T, typename Comp>
void Heap<T, Comp>::build(){
    for(int root = (int(datas.size()) - 2) / 2; root >= 0; root--)
        Heap<T, Comp>::down(root);
    //std::for_each(datas.begin(), datas.end(), [](const T & x){std::cout << x <<" ";}); std::cout << std::endl;
}

template <typename T, typename Comp>
bool Heap<T, Comp>::empty(){
    return datas.size() == 0;
}

Heap<int> htest(int x){
    Heap<int> h1;
    h1.emplace(x);
    return h1;
}

int test_heap(){
    std::vector<int> vec{3,4,5,6,7,89,1,2,3}, v2{3,4,5,6};
    Heap<int> h0, h7, h8;
    Heap<int> h1(vec);//, h11 = vec;
    //h0 = vec ;// 1 8
    Heap<int> h2(std::vector<int>{1,2,3}), h22(std::move(v2)); // 2
    Heap<int> h3={3,4,5}, h33({3,4,2,0}), h333{3,4,5,6}, h3333(Heap<int>{1,2,3});
    h3333 = Heap<int>();
    Heap<int> h4(vec.begin(), vec.end());
    //Heap<int> h5 = std::move(h2), h55(std::move(h1));下　
    Heap<int> h6 = h4, h66(h4);
    h7 = h4;
    h8 = std::move(h7);
    h8 = Heap<int>();
    std::cout<<"\ndone!\n";
    Heap<int> ht = htest(vec.size());
    Heap<int, std::greater<int>> h(vec);
    for(const auto &x:vec) h.emplace(x);
    while(!h.empty())
    {
        std::cout << h.top() << " ";
        h.pop();
    }
    return 0;
}
//int __heapmain = test_heap();

int mhsort(){
    std::vector<int> vec{9,3,4,5,6,7,0,2};
    heap_sort(vec, (int)vec.size());
    std::for_each(vec.begin(), vec.end(), [](const int & a){std::cout << a << " ";}); std::cout<<std::endl;
    return 0;
}
//int __mhsort = mhsort();

int main(){
    return 0;
}

LeetCode Tags

2016-07-16T00:00:00+00:00

Graph

Depth First Search

133. Clone Graph 28 Jun 2016
100. Same Tree 11 Jul 2016
101. Symmetric Tree 11 Jul 2016
104. Maximum Depth of Binary Tree 11 Jul 2016
105. Construct Binary Tree from Preorder and Inorder Traversal 11 Jul 2016
106. Construct Binary Tree from Inorder and Postorder traversal 11 Jul 2016
108. Convert Sorted Array to Binary Search Tree 11 Jul 2016
109. Convert Sorted List to Binary Search Tree 11 Jul 2016
110. Balanced Binary Tree 11 Jul 2016
111. Minimum Depth of Binary Tree 11 Jul 2016
112. Path Sum 11 Jul 2016
113. Path Sum II 11 Jul 2016
114. Flatten Binary Tree to Linked List 11 Jul 2016
116. Populating Next Right Pointers in Each Node 11 Jul 2016
117. Populating Next Right Pointers in Each Node II 11 Jul 2016
124. Binary Tree Maximum Path Sum 11 Jul 2016
98. Validate Binary Search Tree 11 Jul 2016
99. Recover Binary Search Tree 11 Jul 2016
129. Sum Root to Leaf Numbers 13 Jul 2016
199. Binary Tree Right Side View 16 Jul 2016
200. Number of Islands 16 Jul 2016
207. Course Schedule 16 Jul 2016
210. Course Schedule II 16 Jul 2016
257. Binary Tree Paths 16 Jul 2016
306. Additive Number 17 Jul 2016
329. Longest Increasing Path in a Matrix 18 Jul 2016
332. Reconstruct Itinerary 18 Jul 2016
337. House Robber III 18 Jul 2016

Breadth First Search

133. Clone Graph 28 Jun 2016
101. Symmetric Tree 11 Jul 2016
102. Binary Tree Level Order Traversal 11 Jul 2016
103. Binary Tree Zigzag Level Order Traversal 11 Jul 2016
107. Binary Tree Level Order Traversal II 11 Jul 2016
111. Minimum Depth of Binary Tree 11 Jul 2016
126. Word Ladder II 13 Jul 2016
127. Word Ladder 13 Jul 2016
130. Surrounded Regions 13 Jul 2016
199. Binary Tree Right Side View 16 Jul 2016
200. Number of Islands 16 Jul 2016
207. Course Schedule 16 Jul 2016
210. Course Schedule II 16 Jul 2016
279. Perfect Squares 17 Jul 2016
310. Minimum Height Trees 17 Jul 2016

Bit Manipulation

78. Subsets 28 Jun 2016
136. Single Number 13 Jul 2016
137. Single Number II 13 Jul 2016
169. Majority Element 16 Jul 2016
187. Repeated DNA Sequences 16 Jul 2016
190. Reverse Bits 16 Jul 2016
191. Number of 1 Bits 16 Jul 2016
201. Bitwise AND of Numbers Range 16 Jul 2016
231. Power of Two 16 Jul 2016
260. Single Number III 16 Jul 2016
268. Missing Number 17 Jul 2016
318. Maximum Product of Word Lengths 17 Jul 2016
338. Counting Bits 18 Jul 2016
342. Power of Four 18 Jul 2016

Tree

94. Binary Tree Inorder Traversal 07 Jul 2016
95. Unique Binary Search Tree II 07 Jul 2016
100. Same Tree 11 Jul 2016
101. Symmetric Tree 11 Jul 2016
102. Binary Tree Level Order Traversal 11 Jul 2016
103. Binary Tree Zigzag Level Order Traversal 11 Jul 2016
104. Maximum Depth of Binary Tree 11 Jul 2016
105. Construct Binary Tree from Preorder and Inorder Traversal 11 Jul 2016
106. Construct Binary Tree from Inorder and Postorder traversal 11 Jul 2016
107. Binary Tree Level Order Traversal II 11 Jul 2016
108. Convert Sorted Array to Binary Search Tree 11 Jul 2016
110. Balanced Binary Tree 11 Jul 2016
111. Minimum Depth of Binary Tree 11 Jul 2016
112. Path Sum 11 Jul 2016
113. Path Sum II 11 Jul 2016
114. Flatten Binary Tree to Linked List 11 Jul 2016
116. Populating Next Right Pointers in Each Node 11 Jul 2016
117. Populating Next Right Pointers in Each Node II 11 Jul 2016
124. Binary Tree Maximum Path Sum 11 Jul 2016
96. Unique Binary Search Trees 11 Jul 2016
98. Validate Binary Search Tree 11 Jul 2016
99. Recover Binary Search Tree 11 Jul 2016
129. Sum Root to Leaf Numbers 13 Jul 2016
144. Binary Tree Preorder Traversal 13 Jul 2016
145. Binary Tree Postorder Traversal 13 Jul 2016
173. Binary Search Tree Iterator 16 Jul 2016
199. Binary Tree Right Side View 16 Jul 2016
222. Count Complete Tree Nodes 16 Jul 2016
226. Invert Binary Tree 16 Jul 2016
235. Lowest Common Ancestor of a Binary Search Tree 16 Jul 2016
236. Lowest Common Ancestor of a Binary Tree 16 Jul 2016
257. Binary Tree Paths 16 Jul 2016
297. Serialize And Deserialize Binary Tree 17 Jul 2016
331. Verify Preorder Serialization of a Binary Tree 18 Jul 2016
337. House Robber III 18 Jul 2016

Union Find

128. Longest Consecutive Sequence 13 Jul 2016
130. Surrounded Regions 13 Jul 2016
200. Number of Islands 16 Jul 2016

Design

146. LRU Cache 15 Jul 2016
155. Min Stack 15 Jul 2016
173. Binary Search Tree Iterator 16 Jul 2016
208. Implement Trie (Prefix Tree) 16 Jul 2016
211. Add and Search Word - Data structure design 16 Jul 2016
225. Implement Stack Using Queues 16 Jul 2016
232. Implement Queue using Stacks 16 Jul 2016
284. Peeking Iterator 17 Jul 2016
295. Find Median from Data Stream 17 Jul 2016
297. Serialize And Deserialize Binary Tree 17 Jul 2016
341. Flatten Nested List Iterator 18 Jul 2016

Topological Sort

207. Course Schedule 16 Jul 2016
210. Course Schedule II 16 Jul 2016
329. Longest Increasing Path in a Matrix 18 Jul 2016

Trie

208. Implement Trie (Prefix Tree) 16 Jul 2016
211. Add and Search Word - Data structure design 16 Jul 2016

Binary Search Tree

220. Contains Duplicate III 16 Jul 2016

Brainteaser

292. Nim Game 17 Jul 2016
319. Bulb Switcher 17 Jul 2016

Segment Tree

307. Range Sum Query - Mutable 17 Jul 2016

Binary Index Tree

307. Range Sum Query - Mutable 17 Jul 2016

Memoization

329. Longest Increasing Path in a Matrix 18 Jul 2016

Mark

754. Reach a Number 12 Mar 2018

LeetCode Solutions

2016-05-27T00:00:00+00:00

05/27/2016 题解合集 Algorithm LeetCode OJ

近日闲来无事，基本把LeetCode刷了一遍。打算再闲的时候就写写题解，总结一下。因为题目较多，为了避免Leetcode题解泛滥于本博客，所以只用这一篇博客作为所有题解的入口，作为索引或目录页。

以下为刷过的题目列表

ID	Title	Acceptance	Difficulty	Editorial
1	Two Sum	39.1%	Easy	查看题解
2	Add Two Numbers	29.4%	Medium	查看题解
3	Longest Substring Without Repeating Characters	25.2%	Medium	查看题解
4	Median of Two Sorted Arrays	24.3%	Hard	查看题解
5	Longest Palindromic Substring	25.7%	Medium	查看题解
6	ZigZag Conversion	29.1%	Medium	查看题解
7	Reverse Integer	24.5%	Easy	查看题解
8	String to Integer (atoi)	14.2%	Medium	查看题解
9	Palindrome Number	39.3%	Easy	查看题解
10	Regular Expression Matching	24.5%	Hard	查看题解
11	Container With Most Water	39.8%	Medium	查看题解
12	Integer to Roman	48.2%	Medium	查看题解
13	Roman to Integer	50.0%	Easy	查看题解
14	Longest Common Prefix	32.1%	Easy	查看题解
15	3Sum	22.3%	Medium	查看题解
16	3Sum Closest	32.9%	Medium	查看题解
17	Letter Combinations of a Phone Number	38.7%	Medium	查看题解
18	4Sum	28.6%	Medium	查看题解
19	Remove Nth Node From End of List	33.6%	Medium	查看题解
20	Valid Parentheses	34.9%	Easy	查看题解
21	Merge Two Sorted Lists	43.8%	Easy	查看题解
22	Generate Parentheses	51.0%	Medium	查看题解
23	Merge k Sorted Lists	31.0%	Hard	查看题解
24	Swap Nodes in Pairs	41.4%	Medium	查看题解
25	Reverse Nodes in k-Group	33.9%	Hard	查看题解
26	Remove Duplicates from Sorted Array	38.2%	Easy	查看题解
27	Remove Element	42.3%	Easy	查看题解
28	Implement strStr()	30.3%	Easy	查看题解
29	Divide Two Integers	15.8%	Medium	查看题解
30	Substring with Concatenation of All Words	22.5%	Hard	查看题解
31	Next Permutation	29.4%	Medium	查看题解
32	Longest Valid Parentheses	24.1%	Hard	查看题解
33	Search in Rotated Sorted Array	32.2%	Medium	查看题解
34	Find First and Last Position of Element in Sorted Array	32.2%	Medium	查看题解
35	Search Insert Position	40.0%	Easy	查看题解
36	Valid Sudoku	40.0%	Medium	查看题解
37	Sudoku Solver	34.0%	Hard	查看题解
38	Count and Say	38.2%	Easy	查看题解
39	Combination Sum	44.4%	Medium	查看题解
40	Combination Sum II	38.4%	Medium	查看题解
41	First Missing Positive	27.1%	Hard	查看题解
42	Trapping Rain Water	39.9%	Hard	查看题解
43	Multiply Strings	29.0%	Medium	查看题解
44	Wildcard Matching	21.8%	Hard	查看题解
45	Jump Game II	26.5%	Hard	查看题解
46	Permutations	51.0%	Medium	查看题解
47	Permutations II	37.5%	Medium	查看题解
48	Rotate Image	44.8%	Medium	查看题解
49	Group Anagrams	42.2%	Medium	不日更新
50	Pow(x, n)	26.8%	Medium	查看题解
51	N-Queens	35.9%	Hard	查看题解
52	N-Queens II	49.2%	Hard	查看题解
53	Maximum Subarray	41.6%	Easy	查看题解
54	Spiral Matrix	28.6%	Medium	查看题解
55	Jump Game	30.4%	Medium	查看题解
56	Merge Intervals	33.5%	Medium	查看题解
57	Insert Interval	30.0%	Hard	查看题解
58	Length of Last Word	32.0%	Easy	查看题解
59	Spiral Matrix II	43.7%	Medium	查看题解
60	Permutation Sequence	31.1%	Medium	查看题解
61	Rotate List	25.7%	Medium	查看题解
62	Unique Paths	44.9%	Medium	查看题解
63	Unique Paths II	32.8%	Medium	查看题解
64	Minimum Path Sum	43.6%	Medium	查看题解
65	Valid Number	13.3%	Hard	查看题解
66	Plus One	40.0%	Easy	查看题解
67	Add Binary	36.3%	Easy	查看题解
68	Text Justification	21.4%	Hard	查看题解
69	Sqrt(x)	29.7%	Easy	查看题解
70	Climbing Stairs	42.3%	Easy	查看题解
71	Simplify Path	27.3%	Medium	查看题解
72	Edit Distance	34.8%	Hard	查看题解
73	Set Matrix Zeroes	38.0%	Medium	查看题解
74	Search a 2D Matrix	34.4%	Medium	查看题解
75	Sort Colors	40.3%	Medium	查看题解
76	Minimum Window Substring	28.7%	Hard	查看题解
77	Combinations	44.1%	Medium	查看题解
78	Subsets	48.6%	Medium	查看题解
79	Word Search	29.3%	Medium	查看题解
80	Remove Duplicates from Sorted Array II	38.5%	Medium	查看题解
81	Search in Rotated Sorted Array II	32.4%	Medium	查看题解
82	Remove Duplicates from Sorted List II	31.3%	Medium	查看题解
83	Remove Duplicates from Sorted List	41.1%	Easy	查看题解
84	Largest Rectangle in Histogram	29.1%	Hard	查看题解
85	Maximal Rectangle	31.2%	Hard	查看题解
86	Partition List	35.2%	Medium	查看题解
87	Scramble String	30.5%	Hard	查看题解
88	Merge Sorted Array	33.7%	Easy	查看题解
89	Gray Code	44.0%	Medium	查看题解
90	Subsets II	40.2%	Medium	查看题解
91	Decode Ways	21.2%	Medium	查看题解
92	Reverse Linked List II	32.9%	Medium	查看题解
93	Restore IP Addresses	29.7%	Medium	查看题解
94	Binary Tree Inorder Traversal	53.0%	Medium	查看题解
95	Unique Binary Search Trees II	33.6%	Medium	查看题解
96	Unique Binary Search Trees	43.7%	Medium	查看题解
97	Interleaving String	26.3%	Hard	查看题解
98	Validate Binary Search Tree	24.6%	Medium	查看题解
99	Recover Binary Search Tree	32.8%	Hard	查看题解
100	Same Tree	48.7%	Easy	查看题解
101	Symmetric Tree	41.7%	Easy	查看题解
102	Binary Tree Level Order Traversal	45.3%	Medium	查看题解
103	Binary Tree Zigzag Level Order Traversal	38.9%	Medium	查看题解
104	Maximum Depth of Binary Tree	57.5%	Easy	查看题解
105	Construct Binary Tree from Preorder and Inorder Traversal	37.5%	Medium	查看题解
106	Construct Binary Tree from Inorder and Postorder Traversal	36.4%	Medium	查看题解
107	Binary Tree Level Order Traversal II	44.2%	Easy	查看题解
108	Convert Sorted Array to Binary Search Tree	47.3%	Easy	查看题解
109	Convert Sorted List to Binary Search Tree	38.0%	Medium	查看题解
110	Balanced Binary Tree	39.5%	Easy	查看题解
111	Minimum Depth of Binary Tree	34.3%	Easy	查看题解
112	Path Sum	36.1%	Easy	查看题解
113	Path Sum II	38.0%	Medium	查看题解
114	Flatten Binary Tree to Linked List	39.3%	Medium	查看题解
115	Distinct Subsequences	33.6%	Hard	查看题解
116	Populating Next Right Pointers in Each Node	36.5%	Medium	查看题解
117	Populating Next Right Pointers in Each Node II	33.4%	Medium	查看题解
118	Pascal's Triangle	42.7%	Easy	查看题解
119	Pascal's Triangle II	40.4%	Easy	查看题解
120	Triangle	37.0%	Medium	查看题解
121	Best Time to Buy and Sell Stock	44.8%	Easy	查看题解
122	Best Time to Buy and Sell Stock II	49.6%	Easy	查看题解
123	Best Time to Buy and Sell Stock III	31.9%	Hard	查看题解
124	Binary Tree Maximum Path Sum	28.3%	Hard	查看题解
125	Valid Palindrome	29.0%	Easy	查看题解
126	Word Ladder II	16.0%	Hard	查看题解
127	Word Ladder	21.6%	Medium	查看题解
128	Longest Consecutive Sequence	39.7%	Hard	查看题解
129	Sum Root to Leaf Numbers	39.9%	Medium	查看题解
130	Surrounded Regions	21.1%	Medium	查看题解
131	Palindrome Partitioning	38.0%	Medium	查看题解
132	Palindrome Partitioning II	26.0%	Hard	查看题解
133	Clone Graph	25.1%	Medium	查看题解
134	Gas Station	31.8%	Medium	查看题解
135	Candy	26.6%	Hard	查看题解
136	Single Number	57.5%	Easy	查看题解
137	Single Number II	44.1%	Medium	查看题解
138	Copy List with Random Pointer	25.6%	Medium	查看题解
139	Word Break	33.0%	Medium	查看题解
140	Word Break II	25.7%	Hard	查看题解
141	Linked List Cycle	34.6%	Easy	查看题解
142	Linked List Cycle II	29.9%	Medium	查看题解
143	Reorder List	28.6%	Medium	查看题解
144	Binary Tree Preorder Traversal	49.0%	Medium	查看题解
145	Binary Tree Postorder Traversal	45.1%	Hard	查看题解
146	LRU Cache	22.1%	Hard	查看题解
147	Insertion Sort List	35.4%	Medium	查看题解
148	Sort List	32.3%	Medium	查看题解
149	Max Points on a Line	15.3%	Hard	查看题解
150	Evaluate Reverse Polish Notation	30.2%	Medium	查看题解
151	Reverse Words in a String	15.7%	Medium	查看题解
152	Maximum Product Subarray	27.8%	Medium	查看题解
153	Find Minimum in Rotated Sorted Array	41.8%	Medium	查看题解
154	Find Minimum in Rotated Sorted Array II	38.5%	Hard	查看题解
155	Min Stack	33.8%	Easy	查看题解
160	Intersection of Two Linked Lists	30.8%	Easy	查看题解
162	Find Peak Element	40.0%	Medium	查看题解
164	Maximum Gap	31.1%	Hard	查看题解
165	Compare Version Numbers	21.8%	Medium	查看题解
166	Fraction to Recurring Decimal	18.7%	Medium	查看题解
167	Two Sum II - Input array is sorted	47.9%	Easy	不日更新
168	Excel Sheet Column Title	28.1%	Easy	查看题解
169	Majority Element	50.0%	Easy	查看题解
171	Excel Sheet Column Number	50.0%	Easy	查看题解
172	Factorial Trailing Zeroes	36.9%	Easy	查看题解
173	Binary Search Tree Iterator	45.0%	Medium	查看题解
174	Dungeon Game	25.5%	Hard	不日更新
179	Largest Number	24.5%	Medium	查看题解
187	Repeated DNA Sequences	34.4%	Medium	查看题解
188	Best Time to Buy and Sell Stock IV	25.4%	Hard	查看题解
189	Rotate Array	27.4%	Easy	查看题解
190	Reverse Bits	29.2%	Easy	查看题解
191	Number of 1 Bits	40.9%	Easy	查看题解
198	House Robber	40.4%	Easy	查看题解
199	Binary Tree Right Side View	45.0%	Medium	查看题解
200	Number of Islands	38.5%	Medium	查看题解
201	Bitwise AND of Numbers Range	35.0%	Medium	查看题解
202	Happy Number	43.1%	Easy	查看题解
203	Remove Linked List Elements	34.5%	Easy	查看题解
204	Count Primes	27.3%	Easy	查看题解
205	Isomorphic Strings	35.8%	Easy	查看题解
206	Reverse Linked List	50.3%	Easy	查看题解
207	Course Schedule	35.3%	Medium	查看题解
208	Implement Trie (Prefix Tree)	34.5%	Medium	查看题解
209	Minimum Size Subarray Sum	33.4%	Medium	查看题解
210	Course Schedule II	32.2%	Medium	查看题解
211	Add and Search Word - Data structure design	27.6%	Medium	查看题解
212	Word Search II	26.3%	Hard	不日更新
213	House Robber II	34.7%	Medium	查看题解
214	Shortest Palindrome	26.2%	Hard	查看题解
215	Kth Largest Element in an Array	43.7%	Medium	查看题解
216	Combination Sum III	49.1%	Medium	查看题解
217	Contains Duplicate	49.3%	Easy	查看题解
218	The Skyline Problem	30.1%	Hard	不日更新
219	Contains Duplicate II	33.9%	Easy	查看题解
220	Contains Duplicate III	19.0%	Medium	查看题解
221	Maximal Square	31.4%	Medium	查看题解
222	Count Complete Tree Nodes	29.1%	Medium	查看题解
223	Rectangle Area	34.9%	Medium	查看题解
224	Basic Calculator	30.4%	Hard	查看题解
225	Implement Stack using Queues	36.4%	Easy	查看题解
226	Invert Binary Tree	55.6%	Easy	查看题解
227	Basic Calculator II	31.6%	Medium	查看题解
228	Summary Ranges	34.0%	Medium	不日更新
229	Majority Element II	30.5%	Medium	不日更新
230	Kth Smallest Element in a BST	48.1%	Medium	不日更新
231	Power of Two	41.2%	Easy	查看题解
232	Implement Queue using Stacks	40.3%	Easy	查看题解
233	Number of Digit One	29.4%	Hard	不日更新
234	Palindrome Linked List	34.4%	Easy	查看题解
235	Lowest Common Ancestor of a Binary Search Tree	41.9%	Easy	查看题解
236	Lowest Common Ancestor of a Binary Tree	33.0%	Medium	查看题解
237	Delete Node in a Linked List	50.0%	Easy	查看题解
238	Product of Array Except Self	52.3%	Medium	查看题解
239	Sliding Window Maximum	35.8%	Hard	查看题解
240	Search a 2D Matrix II	39.5%	Medium	查看题解
241	Different Ways to Add Parentheses	47.8%	Medium	查看题解
242	Valid Anagram	49.4%	Easy	查看题解
257	Binary Tree Paths	43.6%	Easy	查看题解
258	Add Digits	52.9%	Easy	查看题解
260	Single Number III	55.0%	Medium	查看题解
263	Ugly Number	40.0%	Easy	查看题解
264	Ugly Number II	34.5%	Medium	查看题解
268	Missing Number	46.4%	Easy	查看题解
273	Integer to English Words	23.3%	Hard	查看题解
274	H-Index	34.2%	Medium	查看题解
275	H-Index II	35.0%	Medium	查看题解
278	First Bad Version	27.6%	Easy	查看题解
279	Perfect Squares	39.1%	Medium	查看题解
282	Expression Add Operators	31.4%	Hard	查看题解
283	Move Zeroes	52.6%	Easy	查看题解
284	Peeking Iterator	37.5%	Medium	查看题解
287	Find the Duplicate Number	46.5%	Medium	查看题解
289	Game of Life	40.6%	Medium	查看题解
290	Word Pattern	34.1%	Easy	查看题解
292	Nim Game	55.4%	Easy	查看题解
295	Find Median from Data Stream	32.5%	Hard	查看题解
297	Serialize and Deserialize Binary Tree	37.5%	Hard	查看题解
299	Bulls and Cows	37.4%	Medium	查看题解
300	Longest Increasing Subsequence	39.5%	Medium	查看题解
301	Remove Invalid Parentheses	37.0%	Hard	不日更新
303	Range Sum Query - Immutable	34.9%	Easy	查看题解
304	Range Sum Query 2D - Immutable	29.6%	Medium	查看题解
306	Additive Number	27.9%	Medium	查看题解
307	Range Sum Query - Mutable	25.5%	Medium	查看题解
309	Best Time to Buy and Sell Stock with Cooldown	42.8%	Medium	查看题解
310	Minimum Height Trees	29.2%	Medium	查看题解
312	Burst Balloons	44.9%	Hard	查看题解
313	Super Ugly Number	39.7%	Medium	查看题解
315	Count of Smaller Numbers After Self	35.9%	Hard	不日更新
316	Remove Duplicate Letters	31.1%	Hard	查看题解
318	Maximum Product of Word Lengths	46.9%	Medium	查看题解
319	Bulb Switcher	43.4%	Medium	查看题解
321	Create Maximum Number	24.9%	Hard	不日更新
322	Coin Change	27.6%	Medium	查看题解
324	Wiggle Sort II	26.8%	Medium	查看题解
326	Power of Three	41.0%	Easy	查看题解
327	Count of Range Sum	31.3%	Hard	不日更新
328	Odd Even Linked List	46.8%	Medium	查看题解
329	Longest Increasing Path in a Matrix	38.1%	Hard	查看题解
330	Patching Array	33.0%	Hard	查看题解
331	Verify Preorder Serialization of a Binary Tree	37.7%	Medium	查看题解
332	Reconstruct Itinerary	30.0%	Medium	查看题解
334	Increasing Triplet Subsequence	39.3%	Medium	查看题解
335	Self Crossing	26.6%	Hard	不日更新
336	Palindrome Pairs	28.4%	Hard	不日更新
337	House Robber III	46.1%	Medium	查看题解
338	Counting Bits	63.1%	Medium	查看题解
341	Flatten Nested List Iterator	45.1%	Medium	查看题解
342	Power of Four	39.7%	Easy	查看题解
343	Integer Break	46.8%	Medium	查看题解
344	Reverse String	61.7%	Easy	查看题解
345	Reverse Vowels of a String	40.1%	Easy	查看题解
347	Top K Frequent Elements	51.5%	Medium	查看题解
349	Intersection of Two Arrays	50.7%	Easy	查看题解
350	Intersection of Two Arrays II	45.4%	Easy	查看题解
352	Data Stream as Disjoint Intervals	42.0%	Hard	不日更新
354	Russian Doll Envelopes	32.9%	Hard	不日更新
355	Design Twitter	26.3%	Medium	不日更新
357	Count Numbers with Unique Digits	46.2%	Medium	不日更新
363	Max Sum of Rectangle No Larger Than K	34.2%	Hard	不日更新
365	Water and Jug Problem	28.4%	Medium	不日更新
367	Valid Perfect Square	38.9%	Easy	不日更新
368	Largest Divisible Subset	34.1%	Medium	不日更新
371	Sum of Two Integers	51.0%	Easy	不日更新
372	Super Pow	35.0%	Medium	不日更新
373	Find K Pairs with Smallest Sums	32.1%	Medium	不日更新
374	Guess Number Higher or Lower	37.9%	Easy	不日更新
375	Guess Number Higher or Lower II	36.5%	Medium	不日更新
376	Wiggle Subsequence	36.4%	Medium	不日更新
377	Combination Sum IV	43.4%	Medium	不日更新
378	Kth Smallest Element in a Sorted Matrix	46.7%	Medium	不日更新
380	Insert Delete GetRandom O(1)	40.9%	Medium	不日更新
381	Insert Delete GetRandom O(1) - Duplicates allowed	30.4%	Hard	不日更新
382	Linked List Random Node	48.1%	Medium	不日更新
383	Ransom Note	48.6%	Easy	不日更新
384	Shuffle an Array	48.4%	Medium	不日更新
385	Mini Parser	31.1%	Medium	不日更新
386	Lexicographical Numbers	43.6%	Medium	不日更新
387	First Unique Character in a String	47.8%	Easy	不日更新
388	Longest Absolute File Path	38.1%	Medium	不日更新
389	Find the Difference	52.0%	Easy	不日更新
390	Elimination Game	43.0%	Medium	不日更新
391	Perfect Rectangle	27.5%	Hard	不日更新
392	Is Subsequence	45.3%	Medium	不日更新
393	UTF-8 Validation	34.9%	Medium	不日更新
394	Decode String	42.6%	Medium	不日更新
395	Longest Substring with At Least K Repeating Characters	36.8%	Medium	不日更新
396	Rotate Function	34.4%	Medium	不日更新
397	Integer Replacement	30.7%	Medium	不日更新
398	Random Pick Index	47.1%	Medium	不日更新
399	Evaluate Division	44.3%	Medium	不日更新
400	Nth Digit	29.9%	Easy	不日更新
401	Binary Watch	44.8%	Easy	不日更新
402	Remove K Digits	25.5%	Medium	不日更新
403	Frog Jump	34.0%	Hard	不日更新
404	Sum of Left Leaves	48.1%	Easy	不日更新
405	Convert a Number to Hexadecimal	41.2%	Easy	不日更新
406	Queue Reconstruction by Height	57.4%	Medium	不日更新
407	Trapping Rain Water II	38.1%	Hard	不日更新
409	Longest Palindrome	46.6%	Easy	不日更新
410	Split Array Largest Sum	40.4%	Hard	不日更新
412	Fizz Buzz	58.0%	Easy	不日更新
413	Arithmetic Slices	54.5%	Medium	不日更新
414	Third Maximum Number	28.2%	Easy	不日更新
415	Add Strings	42.3%	Easy	不日更新
416	Partition Equal Subset Sum	38.9%	Medium	不日更新
417	Pacific Atlantic Water Flow	35.6%	Medium	不日更新
419	Battleships in a Board	64.3%	Medium	不日更新
420	Strong Password Checker	18.5%	Hard	不日更新
421	Maximum XOR of Two Numbers in an Array	49.5%	Medium	不日更新
423	Reconstruct Original Digits from English	44.9%	Medium	不日更新
424	Longest Repeating Character Replacement	42.9%	Medium	不日更新
432	All O`one Data Structure	28.4%	Hard	不日更新
433	Minimum Genetic Mutation	36.2%	Medium	不日更新
434	Number of Segments in a String	36.4%	Easy	不日更新
435	Non-overlapping Intervals	41.0%	Medium	不日更新
436	Find Right Interval	41.8%	Medium	不日更新
437	Path Sum III	40.7%	Easy	不日更新
438	Find All Anagrams in a String	34.9%	Easy	不日更新
440	K-th Smallest in Lexicographical Order	25.8%	Hard	不日更新
441	Arranging Coins	36.7%	Easy	不日更新
442	Find All Duplicates in an Array	58.5%	Medium	不日更新
443	String Compression	35.8%	Easy	不日更新
445	Add Two Numbers II	47.8%	Medium	不日更新
446	Arithmetic Slices II - Subsequence	28.6%	Hard	不日更新
447	Number of Boomerangs	48.1%	Easy	不日更新
448	Find All Numbers Disappeared in an Array	51.6%	Easy	不日更新
449	Serialize and Deserialize BST	44.1%	Medium	不日更新
450	Delete Node in a BST	38.1%	Medium	不日更新
451	Sort Characters By Frequency	53.4%	Medium	不日更新
452	Minimum Number of Arrows to Burst Balloons	44.9%	Medium	不日更新
453	Minimum Moves to Equal Array Elements	48.5%	Easy	不日更新
454	4Sum II	48.6%	Medium	不日更新
455	Assign Cookies	47.5%	Easy	不日更新
456	132 Pattern	27.3%	Medium	不日更新
457	Circular Array Loop	25.4%	Medium	不日更新
458	Poor Pigs	43.8%	Easy	不日更新
459	Repeated Substring Pattern	38.8%	Easy	不日更新
460	LFU Cache	26.7%	Hard	不日更新
461	Hamming Distance	69.5%	Easy	不日更新
462	Minimum Moves to Equal Array Elements II	52.0%	Medium	不日更新
463	Island Perimeter	59.0%	Easy	不日更新
464	Can I Win	26.2%	Medium	不日更新
466	Count The Repetitions	27.1%	Hard	不日更新
467	Unique Substrings in Wraparound String	33.2%	Medium	不日更新
468	Validate IP Address	20.5%	Medium	不日更新
472	Concatenated Words	32.2%	Hard	不日更新
473	Matchsticks to Square	35.2%	Medium	不日更新
474	Ones and Zeroes	38.8%	Medium	不日更新
475	Heaters	30.1%	Easy	不日更新
476	Number Complement	61.5%	Easy	不日更新
477	Total Hamming Distance	47.9%	Medium	不日更新
479	Largest Palindrome Product	26.2%	Easy	不日更新
480	Sliding Window Median	30.7%	Hard	不日更新
481	Magical String	45.5%	Medium	不日更新
482	License Key Formatting	39.1%	Easy	不日更新
483	Smallest Good Base	33.7%	Hard	不日更新
485	Max Consecutive Ones	53.8%	Easy	不日更新
486	Predict the Winner	46.0%	Medium	不日更新
488	Zuma Game	36.5%	Hard	不日更新
491	Increasing Subsequences	40.3%	Medium	不日更新
492	Construct the Rectangle	48.0%	Easy	不日更新
493	Reverse Pairs	21.4%	Hard	不日更新
494	Target Sum	44.2%	Medium	不日更新
495	Teemo Attacking	51.4%	Medium	不日更新
496	Next Greater Element I	57.4%	Easy	不日更新
498	Diagonal Traverse	44.1%	Medium	不日更新
500	Keyboard Row	60.8%	Easy	不日更新
501	Find Mode in Binary Search Tree	38.1%	Easy	不日更新
502	IPO	36.6%	Hard	不日更新
503	Next Greater Element II	48.7%	Medium	不日更新
504	Base 7	44.0%	Easy	不日更新
506	Relative Ranks	47.3%	Easy	不日更新
507	Perfect Number	32.6%	Easy	不日更新
508	Most Frequent Subtree Sum	52.9%	Medium	不日更新
513	Find Bottom Left Tree Value	57.1%	Medium	不日更新
514	Freedom Trail	39.7%	Hard	不日更新
515	Find Largest Value in Each Tree Row	56.4%	Medium	不日更新
516	Longest Palindromic Subsequence	44.0%	Medium	不日更新
517	Super Washing Machines	36.4%	Hard	不日更新
518	Coin Change 2	39.0%	Medium	不日更新
520	Detect Capital	51.9%	Easy	不日更新
521	Longest Uncommon Subsequence I	55.8%	Easy	不日更新
522	Longest Uncommon Subsequence II	32.4%	Medium	不日更新
523	Continuous Subarray Sum	23.7%	Medium	不日更新
524	Longest Word in Dictionary through Deleting	43.9%	Medium	不日更新
525	Contiguous Array	42.1%	Medium	不日更新
526	Beautiful Arrangement	52.9%	Medium	不日更新
529	Minesweeper	50.4%	Medium	不日更新
530	Minimum Absolute Difference in BST	48.7%	Easy	不日更新
532	K-diff Pairs in an Array	28.6%	Easy	不日更新
535	Encode and Decode TinyURL	74.6%	Medium	不日更新
537	Complex Number Multiplication	64.3%	Medium	不日更新
538	Convert BST to Greater Tree	48.9%	Easy	不日更新
539	Minimum Time Difference	46.6%	Medium	不日更新
540	Single Element in a Sorted Array	56.2%	Medium	不日更新
541	Reverse String II	44.4%	Easy	不日更新
542	01 Matrix	33.7%	Medium	不日更新
543	Diameter of Binary Tree	45.3%	Easy	不日更新
546	Remove Boxes	36.7%	Hard	不日更新
547	Friend Circles	50.8%	Medium	不日更新
551	Student Attendance Record I	45.0%	Easy	不日更新
552	Student Attendance Record II	31.6%	Hard	不日更新
553	Optimal Division	55.0%	Medium	不日更新
554	Brick Wall	46.9%	Medium	不日更新
556	Next Greater Element III	29.1%	Medium	不日更新
557	Reverse Words in a String III	61.9%	Easy	不日更新
560	Subarray Sum Equals K	40.4%	Medium	不日更新
561	Array Partition I	67.3%	Easy	不日更新
563	Binary Tree Tilt	46.4%	Easy	不日更新
564	Find the Closest Palindrome	17.3%	Hard	不日更新
565	Array Nesting	50.3%	Medium	不日更新
566	Reshape the Matrix	57.9%	Easy	不日更新
567	Permutation in String	36.7%	Medium	不日更新
572	Subtree of Another Tree	40.5%	Easy	不日更新
575	Distribute Candies	58.5%	Easy	不日更新
576	Out of Boundary Paths	30.8%	Medium	不日更新
581	Shortest Unsorted Continuous Subarray	29.3%	Easy	不日更新
583	Delete Operation for Two Strings	44.8%	Medium	不日更新
587	Erect the Fence	33.6%	Hard	不日更新
591	Tag Validator	31.4%	Hard	不日更新
592	Fraction Addition and Subtraction	46.1%	Medium	不日更新
593	Valid Square	39.9%	Medium	不日更新
594	Longest Harmonious Subsequence	41.8%	Easy	不日更新
598	Range Addition II	48.0%	Easy	不日更新
599	Minimum Index Sum of Two Lists	46.6%	Easy	不日更新
600	Non-negative Integers without Consecutive Ones	31.9%	Hard	不日更新
605	Can Place Flowers	30.2%	Easy	不日更新
606	Construct String from Binary Tree	50.5%	Easy	不日更新
609	Find Duplicate File in System	53.2%	Medium	不日更新
611	Valid Triangle Number	43.2%	Medium	不日更新
617	Merge Two Binary Trees	67.8%	Easy	不日更新
621	Task Scheduler	42.9%	Medium	不日更新
623	Add One Row to Tree	46.6%	Medium	不日更新
628	Maximum Product of Three Numbers	44.9%	Easy	不日更新
629	K Inverse Pairs Array	28.0%	Hard	不日更新
630	Course Schedule III	30.0%	Hard	不日更新
632	Smallest Range	44.2%	Hard	不日更新
633	Sum of Square Numbers	32.4%	Easy	不日更新
636	Exclusive Time of Functions	46.3%	Medium	不日更新
637	Average of Levels in Binary Tree	56.9%	Easy	不日更新
638	Shopping Offers	46.5%	Medium	不日更新
639	Decode Ways II	24.1%	Hard	不日更新
640	Solve the Equation	38.9%	Medium	不日更新
643	Maximum Average Subarray I	38.1%	Easy	不日更新
645	Set Mismatch	40.0%	Easy	不日更新
646	Maximum Length of Pair Chain	47.3%	Medium	不日更新
647	Palindromic Substrings	54.6%	Medium	不日更新
648	Replace Words	49.5%	Medium	不日更新
649	Dota2 Senate	36.7%	Medium	不日更新
650	2 Keys Keyboard	45.9%	Medium	不日更新
652	Find Duplicate Subtrees	41.2%	Medium	不日更新
653	Two Sum IV - Input is a BST	51.0%	Easy	不日更新
654	Maximum Binary Tree	71.4%	Medium	不日更新
655	Print Binary Tree	49.3%	Medium	不日更新
657	Robot Return to Origin	69.4%	Easy	不日更新
658	Find K Closest Elements	35.4%	Medium	不日更新
659	Split Array into Consecutive Subsequences	37.9%	Medium	不日更新
661	Image Smoother	47.1%	Easy	不日更新
662	Maximum Width of Binary Tree	39.0%	Medium	不日更新
664	Strange Printer	35.3%	Hard	不日更新
665	Non-decreasing Array	19.7%	Easy	不日更新
667	Beautiful Arrangement II	50.9%	Medium	不日更新
668	Kth Smallest Number in Multiplication Table	39.6%	Hard	不日更新
669	Trim a Binary Search Tree	58.8%	Easy	不日更新
670	Maximum Swap	38.9%	Medium	不日更新
671	Second Minimum Node In a Binary Tree	42.6%	Easy	不日更新
672	Bulb Switcher II	49.3%	Medium	不日更新
673	Number of Longest Increasing Subsequence	32.3%	Medium	不日更新
674	Longest Continuous Increasing Subsequence	43.1%	Easy	不日更新
675	Cut Off Trees for Golf Event	27.7%	Hard	不日更新
676	Implement Magic Dictionary	49.7%	Medium	不日更新
677	Map Sum Pairs	50.6%	Medium	不日更新
678	Valid Parenthesis String	30.5%	Medium	不日更新
679	24 Game	39.9%	Hard	不日更新
680	Valid Palindrome II	32.9%	Easy	不日更新
682	Baseball Game	59.0%	Easy	不日更新
684	Redundant Connection	47.6%	Medium	不日更新
685	Redundant Connection II	28.8%	Hard	不日更新
686	Repeated String Match	31.3%	Easy	不日更新
687	Longest Univalue Path	32.7%	Easy	不日更新
688	Knight Probability in Chessboard	41.1%	Medium	不日更新
689	Maximum Sum of 3 Non-Overlapping Subarrays	42.5%	Hard	不日更新
690	Employee Importance	52.0%	Easy	不日更新
691	Stickers to Spell Word	36.6%	Hard	不日更新
692	Top K Frequent Words	43.1%	Medium	不日更新
693	Binary Number with Alternating Bits	56.7%	Easy	不日更新
695	Max Area of Island	53.8%	Medium	不日更新
696	Count Binary Substrings	51.5%	Easy	不日更新
697	Degree of an Array	47.7%	Easy	不日更新
698	Partition to K Equal Sum Subsets	39.4%	Medium	不日更新
699	Falling Squares	38.4%	Hard	不日更新
712	Minimum ASCII Delete Sum for Two Strings	52.3%	Medium	不日更新
713	Subarray Product Less Than K	34.4%	Medium	不日更新
714	Best Time to Buy and Sell Stock with Transaction Fee	48.1%	Medium	不日更新
715	Range Module	32.1%	Hard	不日更新
717	1-bit and 2-bit Characters	48.5%	Easy	不日更新
718	Maximum Length of Repeated Subarray	43.0%	Medium	不日更新
719	Find K-th Smallest Pair Distance	28.1%	Hard	不日更新
720	Longest Word in Dictionary	42.3%	Easy	不日更新
721	Accounts Merge	36.6%	Medium	不日更新
722	Remove Comments	29.2%	Medium	不日更新
724	Find Pivot Index	39.5%	Easy	不日更新
725	Split Linked List in Parts	47.6%	Medium	不日更新
726	Number of Atoms	43.6%	Hard	不日更新
728	Self Dividing Numbers	67.3%	Easy	不日更新
729	My Calendar I	44.7%	Medium	不日更新
730	Count Different Palindromic Subsequences	37.2%	Hard	不日更新
731	My Calendar II	40.4%	Medium	不日更新
732	My Calendar III	51.0%	Hard	不日更新
733	Flood Fill	48.3%	Easy	不日更新
735	Asteroid Collision	37.1%	Medium	不日更新
736	Parse Lisp Expression	41.1%	Hard	不日更新
738	Monotone Increasing Digits	41.1%	Medium	不日更新
739	Daily Temperatures	56.4%	Medium	不日更新
740	Delete and Earn	44.3%	Medium	不日更新
741	Cherry Pickup	25.6%	Hard	不日更新
709	To Lower Case	74.5%	Easy	不日更新
743	Network Delay Time	37.7%	Easy	不日更新
744	Find Smallest Letter Greater Than Target	42.9%	Easy	不日更新
745	Prefix and Suffix Search	27.9%	Hard	不日更新
746	Min Cost Climbing Stairs	44.4%	Easy	不日更新
747	Largest Number At Least Twice of Others	39.9%	Easy	不日更新
748	Shortest Completing Word	52.7%	Easy	不日更新
749	Contain Virus	40.7%	Hard	不日更新
752	Open the Lock	42.3%	Medium	不日更新
753	Cracking the Safe	42.9%	Hard	不日更新
754	Reach a Number	29.6%	Easy	不日更新
756	Pyramid Transition Matrix	48.1%	Medium	不日更新
757	Set Intersection Size At Least Two	35.0%	Hard	不日更新
761	Special Binary String	46.5%	Hard	不日更新
429	N-ary Tree Level Order Traversal	55.7%	Easy	不日更新
430	Flatten a Multilevel Doubly Linked List	36.1%	Medium	不日更新
762	Prime Number of Set Bits in Binary Representation	56.3%	Easy	不日更新
763	Partition Labels	66.0%	Medium	不日更新
764	Largest Plus Sign	41.5%	Medium	不日更新
765	Couples Holding Hands	49.0%	Hard	不日更新
427	Construct Quad Tree	48.9%	Easy	不日更新
558	Quad Tree Intersection	36.3%	Easy	不日更新
559	Maximum Depth of N-ary Tree	62.2%	Easy	不日更新
589	N-ary Tree Preorder Traversal	63.0%	Easy	不日更新
590	N-ary Tree Postorder Traversal	62.9%	Easy	不日更新
766	Toeplitz Matrix	59.7%	Easy	不日更新
767	Reorganize String	39.5%	Medium	不日更新
768	Max Chunks To Make Sorted II	44.0%	Hard	不日更新
769	Max Chunks To Make Sorted	49.4%	Medium	不日更新
770	Basic Calculator IV	41.7%	Hard	不日更新
771	Jewels and Stones	81.7%	Easy	不日更新
700	Search in a Binary Search Tree	62.6%	Easy	不日更新
701	Insert into a Binary Search Tree	67.8%	Medium	不日更新
773	Sliding Puzzle	47.8%	Hard	不日更新
703	Kth Largest Element in a Stream	39.4%	Easy	不日更新
775	Global and Local Inversions	36.1%	Medium	不日更新
704	Binary Search	39.9%	Easy	不日更新
777	Swap Adjacent in LR String	30.1%	Medium	不日更新
778	Swim in Rising Water	45.0%	Hard	不日更新
779	K-th Symbol in Grammar	37.4%	Medium	不日更新
780	Reaching Points	25.3%	Hard	不日更新
781	Rabbits in Forest	49.7%	Medium	不日更新
782	Transform to Chessboard	38.0%	Hard	不日更新
783	Minimum Distance Between BST Nodes	48.6%	Easy	不日更新
784	Letter Case Permutation	53.6%	Easy	不日更新
785	Is Graph Bipartite?	40.3%	Medium	不日更新
786	K-th Smallest Prime Fraction	35.7%	Hard	不日更新
787	Cheapest Flights Within K Stops	31.4%	Medium	不日更新
788	Rotated Digits	51.2%	Easy	不日更新
789	Escape The Ghosts	53.4%	Medium	不日更新
790	Domino and Tromino Tiling	34.0%	Medium	不日更新
791	Custom Sort String	59.6%	Medium	不日更新
792	Number of Matching Subsequences	39.1%	Medium	不日更新
793	Preimage Size of Factorial Zeroes Function	39.5%	Hard	不日更新
794	Valid Tic-Tac-Toe State	28.0%	Medium	不日更新
795	Number of Subarrays with Bounded Maximum	41.4%	Medium	不日更新
796	Rotate String	48.7%	Easy	不日更新
797	All Paths From Source to Target	67.6%	Medium	不日更新
798	Smallest Rotation with Highest Score	36.7%	Hard	不日更新
799	Champagne Tower	30.8%	Medium	不日更新
705	Design HashSet	43.4%	Easy	不日更新
706	Design HashMap	48.9%	Easy	不日更新
801	Minimum Swaps To Make Sequences Increasing	32.7%	Medium	不日更新
802	Find Eventual Safe States	41.3%	Medium	不日更新
803	Bricks Falling When Hit	24.8%	Hard	不日更新
804	Unique Morse Code Words	71.7%	Easy	不日更新
805	Split Array With Same Average	22.4%	Hard	不日更新
806	Number of Lines To Write String	61.8%	Easy	不日更新
807	Max Increase to Keep City Skyline	80.1%	Medium	不日更新
808	Soup Servings	34.5%	Medium	不日更新
809	Expressive Words	39.4%	Medium	不日更新
810	Chalkboard XOR Game	42.0%	Hard	不日更新
811	Subdomain Visit Count	61.6%	Easy	不日更新
812	Largest Triangle Area	53.8%	Easy	不日更新
813	Largest Sum of Averages	42.4%	Medium	不日更新
814	Binary Tree Pruning	68.3%	Medium	不日更新
815	Bus Routes	36.1%	Hard	不日更新
816	Ambiguous Coordinates	42.4%	Medium	不日更新
817	Linked List Components	51.9%	Medium	不日更新
818	Race Car	31.2%	Hard	不日更新
819	Most Common Word	41.6%	Easy	不日更新
707	Design Linked List	19.1%	Easy	不日更新
820	Short Encoding of Words	44.5%	Medium	不日更新
821	Shortest Distance to a Character	61.1%	Easy	不日更新
822	Card Flipping Game	38.6%	Medium	不日更新
823	Binary Trees With Factors	30.5%	Medium	不日更新
824	Goat Latin	55.2%	Easy	不日更新
825	Friends Of Appropriate Ages	33.1%	Medium	不日更新
826	Most Profit Assigning Work	33.2%	Medium	不日更新
827	Making A Large Island	40.5%	Hard	不日更新
828	Unique Letter String	36.7%	Hard	不日更新
829	Consecutive Numbers Sum	29.5%	Hard	不日更新
830	Positions of Large Groups	46.2%	Easy	不日更新
831	Masking Personal Information	41.6%	Medium	不日更新
641	Design Circular Deque	47.9%	Medium	不日更新
622	Design Circular Queue	36.7%	Medium	不日更新
832	Flipping an Image	69.1%	Easy	不日更新
833	Find And Replace in String	41.8%	Medium	不日更新
834	Sum of Distances in Tree	35.1%	Hard	不日更新
835	Image Overlap	47.4%	Medium	不日更新
836	Rectangle Overlap	44.4%	Easy	不日更新
837	New 21 Game	26.9%	Medium	不日更新
838	Push Dominoes	41.6%	Medium	不日更新
839	Similar String Groups	32.9%	Hard	不日更新
840	Magic Squares In Grid	34.7%	Easy	不日更新
841	Keys and Rooms	57.4%	Medium	不日更新
842	Split Array into Fibonacci Sequence	33.8%	Medium	不日更新
843	Guess the Word	39.2%	Hard	不日更新
844	Backspace String Compare	43.3%	Easy	不日更新
845	Longest Mountain in Array	32.2%	Medium	不日更新
846	Hand of Straights	46.0%	Medium	不日更新
847	Shortest Path Visiting All Nodes	43.7%	Hard	不日更新
848	Shifting Letters	37.0%	Medium	不日更新
849	Maximize Distance to Closest Person	38.5%	Easy	不日更新
850	Rectangle Area II	41.7%	Hard	不日更新
851	Loud and Rich	45.0%	Medium	不日更新
852	Peak Index in a Mountain Array	67.1%	Easy	不日更新
853	Car Fleet	35.2%	Medium	不日更新
854	K-Similar Strings	31.3%	Hard	不日更新
855	Exam Room	33.6%	Medium	不日更新
856	Score of Parentheses	53.5%	Medium	不日更新
857	Minimum Cost to Hire K Workers	44.6%	Hard	不日更新
858	Mirror Reflection	50.0%	Medium	不日更新
859	Buddy Strings	26.6%	Easy	不日更新
860	Lemonade Change	49.3%	Easy	不日更新
861	Score After Flipping Matrix	67.1%	Medium	不日更新
862	Shortest Subarray with Sum at Least K	19.7%	Hard	不日更新
863	All Nodes Distance K in Binary Tree	43.1%	Medium	不日更新
710	Random Pick with Blacklist	29.8%	Hard	不日更新
864	Shortest Path to Get All Keys	33.3%	Hard	不日更新
865	Smallest Subtree with all the Deepest Nodes	52.8%	Medium	不日更新
866	Prime Palindrome	18.3%	Medium	不日更新
867	Transpose Matrix	63.3%	Easy	不日更新
868	Binary Gap	58.8%	Easy	不日更新
869	Reordered Power of 2	48.0%	Medium	不日更新
870	Advantage Shuffle	40.0%	Medium	不日更新
871	Minimum Number of Refueling Stops	26.6%	Hard	不日更新
470	Implement Rand10() Using Rand7()	42.9%	Medium	不日更新
872	Leaf-Similar Trees	60.5%	Easy	不日更新
873	Length of Longest Fibonacci Subsequence	42.4%	Medium	不日更新
874	Walking Robot Simulation	28.4%	Easy	不日更新
875	Koko Eating Bananas	42.6%	Medium	不日更新
876	Middle of the Linked List	62.7%	Easy	不日更新
877	Stone Game	58.1%	Medium	不日更新
878	Nth Magical Number	23.5%	Hard	不日更新
879	Profitable Schemes	33.8%	Hard	不日更新
528	Random Pick with Weight	41.7%	Medium	不日更新
519	Random Flip Matrix	32.3%	Medium	不日更新
497	Random Point in Non-overlapping Rectangles	33.2%	Medium	不日更新
478	Generate Random Point in a Circle	33.8%	Medium	不日更新
880	Decoded String at Index	22.4%	Medium	不日更新
881	Boats to Save People	39.8%	Medium	不日更新
882	Reachable Nodes In Subdivided Graph	34.5%	Hard	不日更新
883	Projection Area of 3D Shapes	64.6%	Easy	不日更新
884	Uncommon Words from Two Sentences	59.8%	Easy	不日更新
885	Spiral Matrix III	62.8%	Medium	不日更新
886	Possible Bipartition	38.7%	Medium	不日更新
887	Super Egg Drop	23.3%	Hard	不日更新
888	Fair Candy Swap	53.6%	Easy	不日更新
889	Construct Binary Tree from Preorder and Postorder Traversal	55.4%	Medium	不日更新
890	Find and Replace Pattern	68.8%	Medium	不日更新
891	Sum of Subsequence Widths	25.6%	Hard	不日更新
892	Surface Area of 3D Shapes	54.7%	Easy	不日更新
893	Groups of Special-Equivalent Strings	60.5%	Easy	不日更新
894	All Possible Full Binary Trees	65.9%	Medium	不日更新
895	Maximum Frequency Stack	48.2%	Hard	不日更新
896	Monotonic Array	54.6%	Easy	不日更新
897	Increasing Order Search Tree	57.8%	Easy	不日更新
898	Bitwise ORs of Subarrays	31.5%	Medium	不日更新
899	Orderly Queue	43.0%	Hard	不日更新
900	RLE Iterator	43.8%	Medium	不日更新
901	Online Stock Span	43.7%	Medium	不日更新
902	Numbers At Most N Given Digit Set	26.1%	Hard	不日更新
903	Valid Permutations for DI Sequence	39.6%	Hard	不日更新
904	Fruit Into Baskets	39.1%	Medium	不日更新
905	Sort Array By Parity	70.8%	Easy	不日更新
906	Super Palindromes	29.1%	Hard	不日更新
907	Sum of Subarray Minimums	21.6%	Medium	不日更新
908	Smallest Range I	63.4%	Easy	不日更新
909	Snakes and Ladders	26.1%	Medium	不日更新
910	Smallest Range II	19.6%	Medium	不日更新
911	Online Election	43.0%	Medium	不日更新
913	Cat and Mouse	23.0%	Hard	不日更新
914	X of a Kind in a Deck of Cards	33.0%	Easy	不日更新
915	Partition Array into Disjoint Intervals	40.0%	Medium	不日更新
916	Word Subsets	43.1%	Medium	不日更新
917	Reverse Only Letters	56.2%	Easy	不日更新
918	Maximum Sum Circular Subarray	26.2%	Medium	不日更新
919	Complete Binary Tree Inserter	53.5%	Medium	不日更新
920	Number of Music Playlists	40.4%	Hard	不日更新
921	Minimum Add to Make Parentheses Valid	69.8%	Medium	不日更新
922	Sort Array By Parity II	66.6%	Easy	不日更新
923	3Sum With Multiplicity	28.3%	Medium	不日更新
924	Minimize Malware Spread	35.5%	Hard	不日更新
925	Long Pressed Name	44.4%	Easy	不日更新
926	Flip String to Monotone Increasing	43.3%	Medium	不日更新
927	Three Equal Parts	26.8%	Hard	不日更新
928	Minimize Malware Spread II	36.9%	Hard	不日更新
929	Unique Email Addresses	79.7%	Easy	不日更新
930	Binary Subarrays With Sum	33.5%	Medium	不日更新
931	Minimum Falling Path Sum	55.4%	Medium	不日更新
932	Beautiful Array	45.1%	Medium	不日更新
933	Number of Recent Calls	63.0%	Easy	不日更新
934	Shortest Bridge	42.1%	Medium	不日更新
935	Knight Dialer	33.6%	Medium	不日更新
936	Stamping The Sequence	26.7%	Hard	不日更新

Hihocoder 1288 Font Size

2016-04-07T00:00:00+00:00

描述
输入
输出
解题思路
代码

时间限制:10000ms 单点时限:1000ms 内存限制:256MB

描述

Steven loves reading book on his phone. The book he reads now consists of N paragraphs and the i-th paragraph contains ai characters. Steven wants to make the characters easier to read, so he decides to increase the font size of characters. But the size of Steven’s phone screen is limited. Its width is W and height is H. As a result, if the font size of characters is S then it can only show ⌊W / S⌋ characters in a line and ⌊H / S⌋ lines in a page. (⌊x⌋ is the largest integer no more than x)
So here’s the question, if Steven wants to control the number of pages no more than P, what’s the maximum font size he can set? Note that paragraphs must start in a new line and there is no empty line between paragraphs.

输入

Input may contain multiple test cases. The first line is an integer TASKS, representing the number of test cases. For each test case, the first line contains four integers N, P, W and H, as described above. The second line contains N integers a1, a2, … aN, indicating the number of characters in each paragraph. For all test cases, $1 <= N <= 10^3$ $1 <= W, H, ai <= 10^3$ $1 <= P <= 10^6$ There is always a way to control the number of pages no more than P.

输出

For each test case, output a line with an integer Ans, indicating the maximum font size Steven can set.

样例输入

样例输出

3
2

解题思路

好像暴力都可以过，不过还是二分是正道（二分写的渣了点。。。）

代码

#include <stdio.h>
#include <algorithm>

using std::min;
using std::max;

int data[10000];

int check(int n, int para,int w,int h)
{
    int ret = 0;
    int w_cnt = w/n;
    int l_cnt = h/n;
    if(!w_cnt || !l_cnt)
        return 0x3fffffff;
    for(int i = 0; i < para; i++)
        ret += (data[i] + w_cnt - 1)/w_cnt;
    ret = (ret + l_cnt - 1)/l_cnt;
    return ret;
}

int main()
{
    int T, para, page,w,h;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d%d",&para,&page,&w,&h);
        for(int i = 0; i < para; i++)
            scanf("%d",&data[i]);
        int low = 1, up = min(w,h);
        int cnt,mid = 1,ans = 0;

        while(low <= up)
        {
            mid = (low + up) / 2;
            cnt = check(mid,para,w,h);
            if(cnt > page)
                up = mid -1;
            else
            {
                ans = mid;
                low = mid + 1;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

Hihocoder 1291 Buiding in Sandbox

2016-04-07T00:00:00+00:00

描述
输入
输出
样例提示
解题思路
代码

时间限制:30000ms 单点时限:3000ms 内存限制:256MB

描述

Little Hi is playing a sandbox voxel game. In the game the whole world is constructed by massive 1x1x1 cubes. The edges of cubes are parallel to the coordinate axes and the coordinates (x, y, z) of the center of each cube are integers.

At the beginning there is nothing but plane ground in the world. The ground consists of all the cubes of z=0. Little Hi needs to build everything by placing cubes one by one following the rules:

The newly placed cube must be adjacent to the ground or a previously placed cube. Two cubes are adjacent if and only if they share a same face.
The newly placed cube must be accessible from outside which means by moving in 6 directions(up, down, left, right, forward, backward) there is a path from a very far place - say (1000, 1000, 1000) in this problem - to this cube without passing through ground or other cubes.

Given a sequence of cubes Little Hi wants to know if he can build the world by placing the cubes in such order.

输入

The first line contains the number of test cases T(1 <= T <= 10). For each test case the first line is N the number of cubes in the sequence. The following N lines each contain three integers x, y and z indicating the coordinates of a cube. For 20% of the data, 1 <= N <= 1000, 1 <= x, y, z <= 10. For 100% of the data, 1 <= N <= 100000, 1 <= x, y, z <= 100.

输出

For each testcase output “Yes” or “No” indicating if Little Hi can place the cubes in such order.

样例提示

In the first test case three cubes are placed on the ground. It’s OK. In the second test case (1, 3, 2) is neither on the ground nor adjacent to previous cubes. So it can’t be placed. In the last test case (2, 2, 1) can not be reached from outside. So it can’t be placed.

样例输入

样例输出

Yes
No
No

解题思路

BFS

代码

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>

using std::max;
using std::queue;
const int MAXN = 105;
int cube[MAXN][MAXN][MAXN];
int data[100000 + 5][3];

const int dx[] = { 0, 0, 1,-1, 0, 0};
const int dy[] = { 0, 0, 0, 0, 1,-1};
const int dz[] = { 1,-1, 0, 0, 0, 0};
bool bfs(int x,int y,int z,int lim, int tag);

struct State{
    int x,y,z;
    State():x(0),y(0),z(0){}
    State(int a,int b,int c):x(a),y(b),z(c){}
};

bool adjacent(int x,int y,int z)
{
    int a,b,c;
    if(z == 1) return true;
    for(int i = 0; i < 6; i++)
    {
        a = x + dx[i];
        b = y + dy[i];
        c = z + dz[i];
        if( a > 0 && b > 0 && c > 0 && cube[a][b][c])
            return true;
    }
    return false;
}

int main()
{
    int t,x,y,z,lim,cnt;
    bool flag;
    scanf("%d",&t);
    while(t--)
    {
        lim  = 0;
        flag = true;
        scanf("%d",&cnt);
        memset(cube,0,sizeof(cube));
        for(int i = 0; i < cnt; i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            if(!adjacent(x,y,z))
                flag = false;
            cube[x][y][z] = (i + 1);
            data[i][0] = x;
            data[i][1] = y;
            data[i][2] = z;
            lim = max(max(lim,x),max(y,z));
        }
        lim += 1;
        if(flag)
        {
            bfs(lim,lim,lim,lim,cnt+5);
            while(cnt-- && flag)
                flag = bfs(data[cnt][0],data[cnt][1],data[cnt][2],lim,cnt + 5);
        }
        if(flag)
            puts("Yes");
        else
            puts("No");
    }
    return 0;
}

bool bfs(int x,int y,int z,int lim,int tag)
{
    queue<State>  que;
    que.push(State(x,y,z));
    cube[x][y][z] = tag;
    bool ret = false;
    State now;
    int a,b,c;
    while(!que.empty())
    {
        now = que.front(); que.pop();
        for(int i = 0; i < 6; i++)
        {
            a = now.x + dx[i];
            b = now.y + dy[i];
            c = now.z + dz[i];
            if( a < 0 || b < 0 || c < 1 || a > lim || b > lim || c > lim)
                continue;
            if(cube[a][b][c] > tag)
                ret = true;
            if(cube[a][b][c])
                continue;
            cube[a][b][c] = tag;
            que.push(State(a,b,c));
        }
    }
    return ret;
}

/**
3
1 1 1
1 2 1
1 3 2
17
1 1 1
1 2 1
1 3 1
2 3 1
3 3 1
3 2 1
3 1 1
2 1 1

2 1 2
1 1 2
1 2 2
1 3 2
2 3 2
3 3 2
3 2 2
2 2 2
2 2 1

**/

Hihocoder 1290 Demo Day

2016-04-07T00:00:00+00:00

描述
输入
输出
解题思路
SPFA-1
SPFA-2

时间限制:10000ms 单点时限:1000ms 内存限制:256MB

描述

You work as an intern at a robotics startup. Today is your company’s demo day. During the demo your company’s robot will be put in a maze and without any information about the maze, it should be able to find a way out.

The maze consists of N * M grids. Each grid is either empty(represented by ‘.’) or blocked by an obstacle(represented by ‘b’). The robot will be release at the top left corner and the exit is at the bottom right corner.

Unfortunately some sensors on the robot go crazy just before the demo starts. As a result, the robot can only repeats two operations alternatively: keep moving to the right until it can’t and keep moving to the bottom until it can’t. At the beginning, the robot keeps moving to the right.

rrrrbb..            
...r....     ====> The robot route with broken sensors is marked by 'r'.
...rrb..
...bb...

While the FTEs(full-time employees) are busy working on the sensors, you try to save the demo day by rearranging the maze in such a way that even with the broken sensors the robot can reach the exit successfully. You can change a grid from empty to blocked and vice versa. So as not to arouse suspision, you want to change as few grids as possible. What is the mininum number?

输入

Line 1: N, M. Line 2-N+1: the N * M maze. For 20% of the data, N * M <= 16. For 50% of the data, 1 <= N, M <= 8. For 100% of the data, 1<= N, M <= 100.

输出

The minimum number of grids to be changed.

样例输入

4 8
....bb..
........
.....b..
...bb...

样例输出

解题思路

主要是dp和SPFA

SPFA-1

#include <stdio.h>
#include <queue>
#include <string.h>

using std::priority_queue;
const int RIGHT = 0;
const int DOWN = 1;


struct State
{
    int x,y;
    int cost;
    int dir;
    State(int _x,int _y,int l,int d):x(_x),y(_y),cost(l),dir(d){}
    State():x(0),y(0),cost(0),dir(RIGHT){}
    bool operator < (const State & arg) const
    {
        return this->cost > arg.cost;
    }
};

const int  MAXN = (100+5);


char maze[MAXN][MAXN];
int  vis[MAXN][MAXN][2];



int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 0; i < n; i++)
        scanf("%s",maze[i]);
    memset(vis,0x3f,sizeof(vis));
    priority_queue<State> que;
    que.push(State(0,0,0,RIGHT));
    State now,down,right;
    int x,y;
    while(!que.empty())
    {
        now = que.top();que.pop();
        x = now.x;
        y = now.y;
        //printf("%d %d %d\n",x,y,now.cost);
        if(x == n-1 && y == m -1)
        {
            printf("%d\n",now.cost);
            break;
        }
        down = now;
        down.dir = DOWN;
        if(x + 1 < n)//down
        {
            //            if(y+1 < m && maze[x][y+1] != 'b' && now.dir == RIGHT)
            if( y + 1 < m && maze[x][y+1] == '.' && now.dir == RIGHT)
                down.cost  += 1;
            down.x += 1;
            if(maze[x+1][y] == 'b')
                down.cost += 1;
            if(down.cost < vis[down.x][down.y][DOWN])
            {
                que.push(down);
                vis[down.x][down.y][DOWN] = down.cost;
            }
        }
        right  = now;
        right.dir = RIGHT;
        if(y + 1 < m ) //right
        {
            if( x + 1 < n && maze[x+1][y] =='.'  && now.dir == DOWN)
            right.cost += 1;
            if(maze[x][y+1] == 'b')
                right.cost += 1;
            right.y += 1;
            if(right.cost < vis[right.x][right.y][RIGHT])
            {
                que.push(right);
                vis[right.x][right.y][RIGHT] = right.cost;
            }
        }
    }
    return 0;

}
/*

4 8
....bb..
........
.....b..
...bb...

4 8
.b..bb..
..b.....
b..b.b..
.b..bb..

4 8
.b..bb..
..b..b..
b..b.b..
.b..bb..

*/

SPFA-2

#include<cstdio>
#include<algorithm>
//  using namespace std;
#define R 105
#define N 40010
#define M 400000
const int inf=1000000;
#define rep(i,n) for (int i=1;i<=n;++i)
#define fr(i,x,y) for (int i=x;i<=y;++i)
int son[N];
int st[M],ed[M],next[M],cost[M];
int d[N];
int f[N*20];
int S,T,l;
bool b[N],v[N];
int id[R][R],idd;
char s[R][R];
int n,m;
void add(int x,int y,int z,int c)
{
  st[l]=x,ed[l]=y,cost[l]=c,next[l]=son[x],son[x]=l;l++;

}
void spfa()
{
  int h=0,t=1; rep(i,T+1) d[i-1]=inf;
  d[f[1]=S]=0;
  while (h<t){
    int x=f[++h]; b[x]=0;
    for (int p=son[x];p;p=next[p]){
      int y=ed[p];
      if (d[x]+cost[p]<d[y]){
        d[y]=d[x]+cost[p];
        if (!b[y]) b[y]=1,f[++t]=y;
      }

    }
  }
}
void work1()
{
  rep(i,T+1) son[i-1]=0;
  l=2;
  S=idd*4;
  T=S+1;
  add(S,id[1][1]*4+(s[1][1]=='.'?0:2),1,0);
  add(id[n][m]*4+0,T,1,0);
  add(id[n][m]*4+1,T,1,0);

  fr(i,1,n)fr(j,1,m)
  {
    add(id[i][j]*4+0,id[i][j]*4+2,1,1),
    add(id[i][j]*4+1,id[i][j]*4+3,1,1),
    add(id[i][j]*4+2,id[i][j]*4+0,1,1),
    add(id[i][j]*4+3,id[i][j]*4+1,1,1);
  }
  fr(i,1,n)fr(j,1,m-1)
  {
    add(id[i][j]*4+0,id[i][j+1]*4+(s[i][j+1]=='.'?0:2),1,0);
    if (i>1)add(id[i][j]*4+3,id[i-1][j+1]*4+(s[i-1][j+1]=='.'?0:2),1,0);
  }
  fr(i,1,n-1)fr(j,1,m)
  {
    add(id[i][j]*4+1,id[i+1][j]*4+(s[i+1][j]=='.'?1:3),1,0);
    if (j>1)    add(id[i][j]*4+2,id[i+1][j-1]*4+(s[i+1][j-1]=='.'?1:3),1,0);
  }

  fr(i,1,n)fr(j,m,m)
  {
    add(id[i][j]*4+0,id[i][j]*4+1,1,0);
    //add(id[i][j]*4+1,id[i][j]*4+0,1,0);
  }
  fr(i,n,n)fr(j,1,m)
  {
    //add(id[i][j]*4+0,id[i][j]*4+1,1,0);
    add(id[i][j]*4+1,id[i][j]*4+0,1,0);
  }
  spfa();
  printf("%d\n",d[T]);
}

int main()
{   scanf("%d%d",&n,&m);
fr(i,1,n)
scanf("%s",s[i]+1);
idd=0;
fr(i,1,n)
fr(j,1,m)
{
  id[i][j]=idd++;
}
work1();


}
/*
4 8
....bb..
........
.....b..
...bb...
*/

致谢CHM童鞋

Hihocoder 1289 403 Forbidden

2016-04-07T00:00:00+00:00

描述
输入
输出
样例输入
样例输出
解题思路
二叉树版（不算严格的Trie树)
map版

时间限制:10000ms 单点时限:1000ms 内存限制:256MB

描述

Little Hi runs a web server. Sometimes he has to deny access from a certain set of malicious IP addresses while his friends are still allow to access his server. To do this he writes N rules in the configuration file which look like:

allow 1.2.3.4/30
deny 1.1.1.1
allow 127.0.0.1
allow 123.234.12.23/3
deny 0.0.0.0/0

Each rule is in the form: allow | deny address or allow | deny address/mask.

When there comes a request, the rules are checked in sequence until the first match is found. If no rule is matched the request will be allowed. Rule and request are matched if the request address is the same as the rule address or they share the same first mask digits when both written as 32bit binary number.

For example IP “1.2.3.4” matches rule “allow 1.2.3.4” because the addresses are the same. And IP “128.127.8.125” matches rule “deny 128.127.4.100/20” because 10000000011111110000010001100100 (128.127.4.100 as binary number) shares the first 20 (mask) digits with 10000000011111110000100001111101 (128.127.8.125 as binary number).

Now comes M access requests. Given their IP addresses, your task is to find out which ones are allowed and which ones are denied.

输入

Line 1: two integers N and M. Line 2-N+1: one rule on each line. Line N+2-N+M+1: one IP address on each line. All addresses are IPv4 addresses(0.0.0.0 - 255.255.255.255). 0 <= mask <= 32.

For 40% of the data: $1 <= N, M <= 1000$ . For 100% of the data: $1 <= N, M <= 100000$ .

输出

For each request output “YES” or “NO” according to whether it is allowed.

样例输入

5 5
allow 1.2.3.4/30
deny 1.1.1.1
allow 127.0.0.1
allow 123.234.12.23/3
deny 0.0.0.0/0
1.2.3.4
1.2.3.5
1.1.1.1
100.100.100.100
219.142.53.100

样例输出

YES
YES
NO
YES
NO

解题思路

普通青年用Tire树，也可以用map

二叉树版（不算严格的Trie树)

#include <stdio.h>
#include <string.h>

#define INDEX(i) data[i].left

#define ALLOW(i,msk) (infos[INDEX(i)][msk][0])
#define ID(i,msk)  (infos[INDEX(i)][msk][1])

struct Node{
    int left,right;
    Node():left(0),right(0){};
    Node(int l,int r):left(l),right(r){}
};

const int MAXN = 100000 * 40;
Node data[MAXN];
int infos[(1<<17)][33][2];
int icnt = 1;
int cnt = 1;

void add_node(unsigned int ip,int allow,int id,int msk)
{
    unsigned  int mask = 0x80000000;
    int root = 0;
    while(mask)
    {
        if(ip & mask)// 1
        {
            if(data[root].right == 0)
                data[root].right = cnt++;
            root = data[root].right;
        }
        else // 0
        {
            if(data[root].left == 0)
                data[root].left = cnt++;
            root = data[root].left;
        }
        mask >>= 1;
    }
    if(!INDEX(root))
        INDEX(root) = icnt++;
    if(!ID(root,msk))
    {
        ID(root,msk) = id;
        ALLOW(root,msk) = allow;
    }
}

int find_node(unsigned int ip,int msk)
{
    unsigned  int mask = 0x80000000;
    int root = 0;
    while(mask)
    {
        if(ip & mask)// 1
        {
            if(data[root].right == 0)
                return 0;
            root = data[root].right;
        }
        else
        {
            if(data[root].left == 0)
                return 0;
            root = data[root].left;
        }
        mask >>= 1;
    }

    return root;
}

int main()
{
    unsigned  int mask[33];
    mask[0] = 0xffffffff;
    for(int  i = 1; i < 33; i++)
        mask[i] = mask[i-1] << 1;
    memset(infos,0,sizeof(infos));
    int m,n;
    unsigned  int tmp,ans;
    char str[50],ip[50];
    scanf("%d%d",&n,&m);
    for(int j = 0; j < n; j++)
    {
        scanf("%s%s",str,ip);
        int i = 0;
        ans = 0;
        tmp = 0;
        for(;ip[i]!='/' && ip[i]!='\0'; i++)
            if(ip[i] == '.')
            {
                ans = (ans << 8) | tmp;
                tmp = 0;
            }
            else
                tmp = tmp*10 + ip[i] - '0';
        ans = (ans << 8) | tmp;
        tmp = 32;
        if(ip[i] == '/')
        {
            tmp = 0;
            for(i += 1;ip[i]!='\0';i++)
                tmp = tmp * 10 + ip[i] - '0';
            ans = ans & mask[32-tmp];
        }
        add_node(ans,str[0]=='a',j+1,tmp);
    }
    for(int i = 0; i < m; i++)
    {
        scanf("%s",ip);
        ans = 0;
        tmp = 0;
        for(int j= 0;ip[j] != '\0'; j++)
            if(ip[j] == '.')
            {
                ans = (ans << 8) | tmp;
                tmp = 0;
            }
            else
                tmp = tmp*10 +ip[j] - '0';
        ans = (ans << 8) | tmp;
        int index = 0;
        int id = MAXN;
        int mk = 32;
        for(int j = 0 ; j < 33; j++)
        {
            tmp = ans & mask[j];
            int t = find_node(tmp,32-j);
            if(t && ID(t,32-j) &&  ID(t,32-j) < id)
                index = t,id = ID(t,32-j),mk = 32 -j;
        }
        if(!index || ALLOW(index,mk))
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}

/***
5 5

deny 0.0.0.0
allow 0.0.0.1/28
allow 0.0.0.255/28
allow 0.0.0.0
deny 0.0.0.0/24
1.2.3.4
1.2.3.5
1.1.1.1
0.0.0.1
0.0.0.0


***/

map版

#include <stdio.h>
#include <map>

using std::map;

map<long long,int> dat;

int main()
{
    unsigned  int mask[33];
    mask[0] = 0xffffffff;
    for(int  i = 1; i < 33; i++)
        mask[i] = mask[i-1] << 1;
    int m,n;
    unsigned  int tmp,ans;
    char str[50],ip[50];
    scanf("%d%d",&n,&m);
    for(int j = 0; j < n; j++)
    {
        scanf("%s%s",str,ip);
        int i = 0;
        ans = 0;
        tmp = 0;
        for(;ip[i]!='/' && ip[i]!='\0'; i++)
            if(ip[i] == '.')
            {
                ans = (ans << 8) | tmp;
                tmp = 0;
            }
            else
                tmp = tmp*10 + ip[i] - '0';
        ans = (ans << 8) | tmp;
        tmp = 32;
        if(ip[i] == '/')
        {
            tmp = 0;
            for(i += 1;ip[i]!='\0';i++)
                tmp = tmp * 10 + ip[i] - '0';
            ans = ans & mask[32-tmp];
        }
        long long key = 0;
        key |= ans;
        key = (key << 8) | tmp;

        if(!dat.count(key))
            dat[key] = (j << 8) | str[0]=='a';
    }
    for(int i = 0; i < m; i++)
    {
        scanf("%s",ip);
        ans = 0;
        tmp = 0;
        for(int j= 0;ip[j] != '\0'; j++)
            if(ip[j] == '.')
            {
                ans = (ans << 8) | tmp;
                tmp = 0;
            }
            else
                tmp = tmp*10 +ip[j] - '0';
        ans = (ans << 8) | tmp;
        long long key = 0;
        int id = 0x3fffffff;
        for(int j = 0 ; j < 33; j++)
        {
            tmp = ans & mask[j];
            key = tmp;
            key = (key << 8) | (32-j);
            if(dat.count(key) && dat[key] < id)
                id = dat[key];
        }
        if(id & 1)
            puts("YES");
        else
            puts("NO");
    }
    return 0;
}

/***
5 5

deny 0.0.0.0
allow 0.0.0.1/28
allow 0.0.0.255/28
allow 0.0.0.0
deny 0.0.0.0/24
1.2.3.4
1.2.3.5
1.1.1.1
0.0.0.1
0.0.0.0

***/

微软2016校园招聘4月在线笔试题

2016-04-07T00:00:00+00:00

简介
题解

简介

微软2016校园招聘4月在线笔试题，全部四题，全部提交通过了

题解

Problem	Solution
Hihorcoder 1288 Font Size	查看题解
Hihocoder 1289 403 Forbidden	查看题解
Hihocoder 1290 Demo Day	查看题解
Hihocoder 1291 Building in Sandbox	查看题解

Start Here

2016-02-29T00:00:00+00:00

Code and Highlight
MathJax
Lists
Abbreviations (Kramdown)
Set Classes and IDs
Tables
Picture
Links
Horizontal Rules
Emphasis
Footnote

Code and Highlight

Code Block

def show
  @widget = Widget(params[:id])
  respond_to do |format|
    format.html # show.html.erb
    format.json { render json: @widget }
  end
end

#include <stdio.h>
#include <stdlib.h>

int a, b, c;
int *e, *p = NULL;

int main()
{
	puts("Hello,Kean!");
	return 0;
}

Inline code

I think you should use an <addr> element here instead.

MathJax

$a^2 = b^2 + c^2$
For example this is a Block level $x = {-b \pm \sqrt{b^2-4ac} \over 2a}$ formula, and this is an inline Level $x = {-b \pm \sqrt{b^2-4ac} \over 2a}$ formula. \[ \frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} =1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}}{1+\frac{e^{-8\pi}} {1+\ldots} } } } \]

Lists

✘ task one not finish
✓ task two finished
task three not finish
task one not finish - + SPACE + [ ]
task two finished - + SPACE + [x]
This is a complete item

Unordered List

Item 1
Item 2
- Item 2a
- Item 2b

Ordered List

Item 1
Item 2
Item 3
- Item 3a
- Item 3b

Abbreviations (Kramdown)

This is some text not written in HTML but in another language!

Set Classes and IDs

A simple paragraph with an ID attribute.

A blockquote with a title

This item has the class “cls”

Some code here

Tables

First Header	Second Header
Content from cell 1	Content from cell 2
Content in the first column	Content in the second column

Default aligned	Left aligned	Center aligned	Right aligned
First body part	Second cell	Third cell	fourth cell
Second line	foo	strong	baz
Third line	quux	baz	bar
Second body
2 line
ok
sdf
sdfd
dfd
Footer row

Picture

Links

hikean.github.io repository on GitHub.

email example@example.com

GitHub

autolink http://www.github.com/

Horizontal Rules

Emphasis

This text will be italic This will also be italic

This text will be bold This will also be bold

You can combine them

Footnote

This is a footnote¹ ² ³

Some crazy footnote definition. ↩
Blockquotes can be in a footnote.
```
as well as code blocks
```
or, naturally, simple paragraphs. ↩
no code block here (spaces are stripped away) ↩