unique_ptr<int> p(new int(2));   // allowed
unique_ptr<int> p1(p);     // not allowed
unique_ptr<int> p2 = p;  // not allowed
unique_ptr<int> p3(std::move(p)); // allowed
unique_ptr<int> p4 = std::move(p) // allowed

unique_ptr<int> foo()
{
    unique_ptr<int> p(new int(2));
    return p;
}

unique_ptr<int> p5 = foo();  // allowed

#include <memory>
#include <iostream>

class B;

class A
{
  public:
    A()
    {
        std::cout << "A construct.\n";
    }

    ~A()
    {
        std::cout << "A destruct.\n";
    }

    std::shared_ptr<B> pb;

};

class B
{
  public:
    B()
    {
        std::cout << "B construct.\n";
    }

    ~B()
    {
        std::cout << "B destruct.\n";
    }

    std::shared_ptr<A> pa;

};

int main()
{
    std::shared_ptr<A> a(new A());
    std::shared_ptr<B> b(new B());

    a->pb = b;
    b->pa = a;

    return 0;
}

/*************************************************************************
    > File Name: json_type.hpp
    > Author: ce39906
    > Mail: ce39906@163.com
    > Created Time: 2018-07-31 16:25:59
 ************************************************************************/
#ifndef JSON_TYPE_HPP
#define JSON_TYPE_HPP

#include <boost/variant.hpp>

#include <string>
#include <unordered_map>
#include <vector>

namespace json
{

struct Object;
struct Array;

struct String
{
    String() {}
    String(const char* value) : value{value} {}
    String(std::string value) : value{std::move(value)} {}
    std::string value;
};

struct Number
{
    Number() {};
    Number(const double value) : value{value} {}
    double value;
};

struct True
{
};

struct False
{
};

struct Null
{
};

using Value = boost::variant<String,
                             Number,
                             boost::recursive_wrapper<Object>,
                             boost::recursive_wrapper<Array>,
                             True,
                             False,
                             Null>;

struct Object
{
    bool isMember(const std::string& key) const
    {
        return values.count(key) != 0;
    }

    const Value& at(const std::string& key) const
    {
        return values.at(key);
    }

    const Value& operator[](const std::string& key) const
    {
        return values.at(key);
    }

    std::unordered_map<std::string, Value> values;
};

struct Array
{
    const Value& at(const size_t idx) const
    {
        return values.at(idx);
    }

    const Value& operator[](const size_t idx) const
    {
        return values.at(idx);
    }

    size_t size() const
    {
        return values.size();
    }

    const Value& front() const
    {
        return values.front();
    }

    const Value& back() const
    {
        return values.back();
    }

    std::vector<Value> values;
};
} // ns json
#endif

/*************************************************************************
    > File Name: emplace.cpp
    > Author: ce39906
    > Mail: ce39906@163.com
    > Created Time: 2018-07-26 15:03:11
 ************************************************************************/
#include <vector>
#include <cstring>
#include <iostream>
class A
{
  public:
    A (const int size) : size(size)
    {
        if (size)
        {
            data = new char[size];
        }
        std::cout << "I'm constructor.\n";
    }

    A (const A& other)
    {
        size = other.size;
        data = new char[size];
        memcpy(data, other.data, size * sizeof(char));
        std::cout << "I'm copy constructor.\n";
    }

    A (A&& other)
    {
        size = other.size;
        data = other.data;

        other.size = 0;
        other.data = nullptr;
        std::cout << "I'm move constructor.\n";
    }

  private:
    int size;
    char* data = nullptr;
};

int main()
{
    std::vector<A> vec;
    vec.reserve(1024);

    A tmp(5);
    std::cout << "push_back a left value.\n";
    vec.push_back(tmp);

    std::cout << "push_back a right value with std::move.\n";
    vec.push_back(std::move(tmp));

    std::cout << "emplace_back a left value.\n";
    vec.emplace_back(tmp);

    std::cout << "emplace_back a right value with std::move.\n";
    vec.emplace_back(std::move(tmp));

    std::cout << "emplace_back in place.\n";
    vec.emplace_back(5);

    std::cout << "=========================================\n";
    std::cout << "test with buildin string move and emplace_back\n";
    std::cout << "=========================================\n";

    std::vector<std::string> str_vec;
    str_vec.reserve(1024);

    std::string str = "I'd like to be inserted to a container";

    std::cout << "before emplace_back to vec, str is:\n";
    std::cout << str << std::endl;
    std::cout << "c_str address is " << (void*) str.c_str() << std::endl;

    str_vec.emplace_back(std::move(str));

    std::cout << "after emplace_back to vec, str is:\n";
    std::cout << str << std::endl;
    std::cout << "c_str address is " << (void*) str.c_str() << std::endl;
    std::cout << "c_str address of the string in container is "
        << (void*) str_vec.front().c_str() << std::endl;
}

// 使用一组词初始化trie.
void Init(const std::vector<std::string>& dict);
// 在trie 中查找word是否存在.
bool Lookup(const std::string& word);
// 返回在trie中所有以word为前缀的词.
std::vector<std::string> Suggest(const std::string& word);

/*************************************************************************
    > File Name: trie.hpp
    > Author: ce39906
    > Mail: ce39906@163.com
    > Created Time: 2018-07-19 11:12:09
 ************************************************************************/
#ifndef TRIE_HPP
#define TRIE_HPP

#include <vector>
#include <string>

namespace trie
{

class Trie
{
    static constexpr size_t kAsciiCount = 256;
    struct TrieNode
    {
        TrieNode(const char val)
          : val(val), is_end(false), childrens(kAsciiCount, nullptr)
        {
        }

        char val;
        bool is_end;
        std::vector<TrieNode*> childrens;
    };

  public:
    Trie()
    {
        root = new TrieNode('0');
    }

    ~Trie()
    {
        ReleaseTrie(root);
    }

    Trie(const Trie&) = delete;
    Trie& operator = (const Trie&) = delete;

    void Init(const std::vector<std::string>& dict);

    bool Lookup(const std::string& word) const;

    std::vector<std::string> Suggest(const std::string& word) const;

    void PrintSuggs(const std::string& word) const;

  private:

    void Insert(const std::string& word);

    bool Search(const TrieNode* parent, const std::string& word, const size_t idx) const;

    void Dfs(const TrieNode* cur, std::string& word, std::vector<std::string>& suggs) const;

    void ReleaseTrie(const TrieNode* root);

    TrieNode* root;
};
} // ns trie
#endif

class Solution {
public:
    bool reorderedPowerOf2(int N) {
        string str_num = to_string(N);
        // 使用next_permutation 之前应排序
        sort(str_num.begin(), str_num.end());
        do
        {
            if (str_num.front() == '0')
            {
                continue;
            }
            if (isPowerOf2(stoi(str_num)))
            {
                return true;
            }
        } while(next_permutation(str_num.begin(), str_num.end()));

        return false;
    }
private:
    bool isPowerOf2(const int num) const
    {
        return (num & num - 1) == 0;
    }

};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> splitListToParts(ListNode* root, int k) {
        int size = 0;
        ListNode* x = root;
        while(x)
        {
            size++;
            x = x->next;
        }

        const int part_size = size / k;
        const int left = size % k;
        // 直接初始化大小为k的数组，这样不需要对part_size为0的情况进行特殊处理
        vector<ListNode*> res(k);
        for (int i = 0; i < k && root; i++)
        {
            res[i] = root;
            // 前面几个部分需要均摊掉left的部分，每部分消费一个
            for (int j = 1; j < part_size + (i < left); j++)
            {
                root = root->next;
            }
            ListNode* next = root->next;
            // 截断链表
            root->next = nullptr;
            // 更新游标位置
            root = next;
        }
        return res;
    }
};