算法刷题[二]

Trie

• 前缀树, 是一种多叉树数据结构, 与普通的树不同,它的每个节点没有具体的数值. 而是维护一个链表. 比如26字母的前缀树, 就是一个26个元素的字符数组. a-z映射到0-25, 每个元素存放的是下一个节点的地址.
• 下面构造中, 如果判断Trie中有某个单词, 是以最后一个字母的下一个节点的is_end值判断的.会有一个延迟. 构造时导致的.

struct TrieNode{
    bool is_end;
    TrieNode* links[26];
    TrieNode(){
        is_end = false;
        memset(links, 0, sizeof(links));
    }
};
class Trie {
public:
    TrieNode* root;
    /** Initialize your data structure here. */
    Trie() {
       root = new TrieNode();
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        TrieNode* node = root;
        for (char c : word) {
            if (node->links[c - 'a'] == NULL)
                node->links[c - 'a'] = new TrieNode();
            node = node->links[c - 'a'];
        }
        node->is_end = true; // 实际上是结尾的下一个节点, 来判断当前节点是否结尾, 有一个节点的延后
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        TrieNode* node = root;
        for(char c : word) {
            if(node->links[c - 'a'] == NULL)
                return false;
            node = node->links[c - 'a'];
       }
       return node->is_end;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        TrieNode* node = root;
        for(char c : prefix) {
            if (node->links[c - 'a'] == NULL)
                return false;
            node = node->links[c - 'a'];
       }
       return true;
    }
};

上下左右移动

int dir[4][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};     // 左，右，上，下移动，例如：{0, -1}代表向左移动一步
int x = start.x + dir[i][0];
int y = start.y + dir[i][1];

地下迷宫

/**
 * 小青蛙有一天不小心落入了一个地下迷宫,
 * 小青蛙希望用自己仅剩的体力值P跳出这个地下迷宫。
 * 为了让问题简单,假设这是一个n*m的格子迷宫,
 * 迷宫每个位置为0或者1,0代表这个位置有障碍物,
 * 小青蛙达到不了这个位置;1代表小青蛙可以达到的位置。
 * 小青蛙初始在(0,0)位置,地下迷宫的出口在(0,m-1)(保证这两个位置都是1,并且保证一定有起点到终点可达的路径),
 * 小青蛙在迷宫中水平移动一个单位距离需要消耗1点体力值,
 * 向上爬一个单位距离需要消耗3个单位的体力值,
 * 向下移动不消耗体力值,当小青蛙的体力值等于0的时候还没有到达出口,
 * 小青蛙将无法逃离迷宫。现在需要你帮助小青蛙计算出能否用仅剩的体力值跳出迷宫(即达到(0,m-1)位置)。
 */
#include <iostream>
#include <vector>
#include <queue>
#include <set>
#include <algorithm>
#include <limits.h>
using namespace std;

class Point{
public:
    int x;
    int y;
    Point(int x, int y): x(x), y(y) {};
    
    bool operator== (const Point& p) {
        return (this->x == p.x) && (this->y == p.y);
    }
};

class Cmp{
public:
    bool operator()(const Point& p1, const Point& p2) const{
        if (p1.x == p2.x)
            return p1.y < p2.y;
        return p1.x < p2.x;
    }
};

vector<Point> res;
int max_p = INT_MIN;
int dir[4][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
int cost[4] = {-1, -1, -3, 0};
void backtrack(vector<vector<int>> v, vector<Point>& select, int p, Point start , Point target) {
    if (select[select.size() - 1] == target && p >= 0) {
        if (p > max_p) {
            res = select;
            max_p = p;
        }
        return ;
    }
    if (p < 0)
        return ;
    for (int i = 0; i < 4; i++) {
        int x = start.x + dir[i][0];
        int y = start.y + dir[i][1];
        Point point(x, y);
        if (x < 0 || x >= v.size() || y < 0 || y >= v[0].size() || v[x][y] != 1 || find(select.begin(), select.end(), point) != select.end())
            continue;
        select.push_back(point);
        backtrack(v, select, p + cost[i], point, target);
        select.pop_back();
    }
    
}

void solution(vector<Point> & select) {
    int n, m, p;
    cin>>n>>m>>p;
    vector<vector<int>> map(n, vector<int>(m, 0));
    for(int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int val;
            cin>>val;
            map[i][j] = val;
        }
    }
    select.push_back(Point(0,0));
    backtrack(map, select, p, Point(0,0), Point(0, m-1));
}
int main() {
    vector<Point> s;
    solution(s);
    if (res.size() == 0)
        cout<<"Can not escape!"<<endl;
    else {
        for (int i = 0; i < res.size() - 1; i++) {
            cout<<"["<<res[i].x<<","<<res[i].y<<"],";
        }
        cout<<"["<<res[res.size() - 1].x<<","<<res[res.size() - 1].y<<"]";
    }
    return 0;
}

/*输入一个正整数n,求n!(即阶乘)末尾有多少个0？ 比如: n = 10; n! = 3628800,所以答案为2*/
#include <iostream>
using namespace std;

int main(){
    int n;
    cin>>n;
    int count = 0;
    while(n/=5) {
        count += n;
    }
    cout<<count<<endl;
}
/*
解释：比如100/5=20，即有20个数包含因数5：5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100。这20个数中又有20/5=4个包含因数5:25,50,75,100（可以把前面的20个数看成5*1，5*2，5*3，5*4，5*5，5*6，5*7，5*8，5*9，5*10,，5*11，5,12，5*13，5*14，5*15，5*16，5*17，5*18，5*19，5*20），然后这4个数中的因数5又被计算过了，即可。
*/

vector中的最值

#include <vector>
#include <algorithm>
#include <iostream>
 
vector<int>::iterator max_index = max_element(v.begin(), v.end());
vector<int>::iterator min_index = min_element(v.begin(), v.end());
distance(v.begin(), min_index); // 获得两个iterator的距离 (相减)

二分查找

/*
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
*/
int search(vector<int>& nums, int target) {
   int l = 0, r = nums.size() - 1;
   // 如果没有= 一个元素的时候会出错
   while(l <= r) {
       int mid = (l + r) / 2;
       if (target < nums[mid]) {
           r = mid - 1;
       } else if (target > nums[mid]) {
           l = mid + 1;
       } else if (target == nums[mid]) {
           return mid;
       }
   }
   return -1;
}

/*
请实现有重复数字的有序数组的二分查找。
输出在数组中第一个大于等于查找值的位置，如果数组中不存在这样的数，则输出数组长度加一。
*/

int upper_bound_(int n, int v, vector<int>& a) {
	 // write code here
	 int l = 0, r = n - 1;
	 int min = n;
	 while(l <= r) {
	     int mid = (r + l) / 2;
	     if (a[mid] < v) {
	         l = mid + 1;
	     } else if (a[mid] >= v) {
	         r = mid - 1;
	         if (mid < min)
	             min = mid;
	     }
	 }
	 return (min + 1);
	}

LRU

class LRUCache {
public:
    unordered_map<int, list<pair<int, int>>::iterator> mp;
    list<pair<int, int>> cache;
    int cap;
    LRUCache(int capacity) {
        cap = capacity;
    }
    
    int get(int key) {
        auto it = mp.find(key);
        if (it == mp.end())
            return -1;
        auto target = it->second;
        int val = target->second;
        put(key, val);
        return val;
    }
    
    void put(int key, int value) {
        auto it = mp.find(key);
        // 无论存不存在, 都需要删除,在头部插入一个
        if (it != mp.end()) {
            cache.erase(it->second);
            mp.erase(key);
        }
        pair<int, int> p = make_pair(key, value);
        cache.push_front(p);
        // map insert函数插入重复不会覆盖. []插入可以覆盖
        mp[key] = cache.begin();
        if (cache.size() > cap) {
            mp.erase(cache.back().first);
            cache.pop_back();
        }
    }
};

set 插入

set容器插入insert函数会返回一个pair, 
第一个元素是插入的值的iter, (如果插入成功指向新元素, 插入失败指向已存在元素)
第二个元素是bool, 表示是否插入成功

set<int> s;
s.insert(1);
auto i = s.insert(1);
if (i.second)
    cout<<"yes"<<endl;
else
    cout<<"no"<<endl;
cout<<*(i.first)<<endl;

no
1
    

双指针

// 判断链表是否有环, 空间复杂的O(1), 双指针
    bool hasCycle(ListNode *head) {
        if(head == NULL)
            return false;
        ListNode* slow = head;
        ListNode* fast = head->next;
        while(slow != fast) {
            if (fast == NULL || fast->next == NULL)
                return false;
            slow = slow->next;
            fast = fast->next->next;
        }
        return true;
    }


// 可以用set, 但是空间复杂的O(n)
	bool hasCycle(ListNode *head) {
        set<ListNode*> s;
        while(head != NULL) {
            auto res = s.insert(head);
            head = head->next;
            if (!res.second)
                return true;
        }
        return false;
    }

合并链表

/*
1. 使用伪头节点
2. 使用三元表达式, 完美解决了输入为空的情况
3. 尾插法, 需要一个额外的头指针, 用于最后的输出. 
*/

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* root = new ListNode(0);
        ListNode* cur = root;
        while (l1 && l2) {
            if (l1->val < l2->val) {
                cur->next = l1;
                l1 = l1->next;
            }
            else {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        cur->next = l1 != NULL ?l1:l2;
        return root->next;
        
    }
};

数组转容器

// size_t 无符号整数  精度是整形的双倍
int arr[] = {1,3,6,9,2,1,4};
size_t sz = sizeof(arr) / sizeof(int);
vector<int> v(arr, arr + sz);

vector<int> v;
v.assign(begin(arr), end(arr));

原码, 反码, 补码

原码, 反码, 补码 详解