模板 订阅
模板,是指作图或设计方案的固定格式,有时也指DNA复制或转录时,用来产生互补链的核苷酸序列。模板是将一个事物的结构规律予以固定化、标准化的成果,它体现的是结构形式的标准化。 展开全文
模板,是指作图或设计方案的固定格式,有时也指DNA复制或转录时,用来产生互补链的核苷酸序列。模板是将一个事物的结构规律予以固定化、标准化的成果,它体现的是结构形式的标准化。
信息
意    思
使物体成固定型状的模具
拼    音
mú bǎn
中文名
模板
外文名
Template
模板词语信息
mú bǎn使物体成固定型状的模具。模板是新浇混凝土成型用的模型,模板系统由模板、支承件和紧固件组成,要求它能保证结构和构件的形状尺寸准确;有足够的强度、刚度和稳定性;装拆方便可多次使用;接缝严密不漏浆。常用的模板包括木模板、定型组合模板、大型工具式的大模板、爬模、滑升模板、隧道模、台模(飞模、桌模)、永久式模板等。mó bǎn模板指集散控制系统(DCS)中的功能模件,因为大小比模块大,呈板状,所以叫做模板。模板 (template)【分子生物学】模板为核酸中的碱基序列,它可用作DNA或RNA互补链合成的基础。【理论免疫学】是指决定抗体分子结合部位构型的抗原。【遗传学】是指一条DNA单链,是合成RNA互补链或mRNA的模板,又是合成核酸或蛋白质的模板。【网络】在ASP.NET中:一个声明性页段落,用于为模板化的 ASP.NET 服务器控件提供可视化界面。模板包含表示元素,这些元素包括文本文字、HTML 和数据绑定表达式,以及表示 ASP.NET服务器控件的声明性语法元素。模板可以作为带有 .ascx 扩展名的文本文件持续。【工业】指生产、合成重复产物的模子。【建筑】formwork混凝土结构或钢筋混凝土结构成型的模具,由面板和支撑系统(包括龙骨、桁架、小梁等,以及垂直支承结构)、连接配件(包括螺栓、联结卡扣、模板面与支承构件以及支承构件之间联结零、配件)组成。模板按材料分为:钢模板,竹胶板,木模板,塑胶板。竹胶板一般都是一次性的,而其他模板则可以刷上脱模剂、模板漆,以此延长模板的寿命,浇注出高质量的墩柱。模板按其功能分五大类:定型组合模板、一般木模板+钢管(或木立柱支撑)、墙体大模板、飞模(台模)、滑动模板。【 Microsoft Office办公软件】模板是指一个或多个文件,其中所包含的结构和工具构成了已完成文件的样式和页面布局等元素。例如,Word 模板能够生成单个文档,而 FrontPage 模板可以形成整个网站。【面向对象程序设计】模板是建立通用的与数据类型无关的算法的重要手段。C++国际标准ISO 14882将模板正式引入标准库,要求用模板类取代传统C++中定义的类。【 网站】在网上都会有各类网站管理系统提供下载,例如用PHP语言编写的织梦网站管理系统,再或者ASP语言编写的动易、新云等,大家可以通过这些网站管理系统轻松架设网站,这些网站都有自己的模板,叫网站管理系统模板,简称“网站模板”。【集散控制系统(DCS)】moduleDCS内,较模块大的模件,叫做模板。
收起全文
精华内容
下载资源
问答
  • IDEA类和方法注释模板设置(非常详细)

    万次阅读 多人点赞 2018-01-11 10:41:44
    IDEA自带的注释模板不是太好用,我本人到网上搜集了很多资料系统的整理了一下制作了一份比较完整的模板来分享给大家,我不是专业玩博客的,写这篇文章只是为了让大家省事。 这里设置的注释模板采用Eclipse的格式,...

        IDEA自带的注释模板不是太好用,我本人到网上搜集了很多资料系统的整理了一下制作了一份比较完整的模板来分享给大家,我不是专业玩博客的,写这篇文章只是为了让大家省事。

    这里设置的注释模板采用Eclipse的格式,下面先贴出Eclipse的注释模板,我们就按照这种格式来设置:

    类注释模板:                                                                      方法注释模板:

        

    一、首先我们来设置IDEA中类的模板:(IDEA中在创建类时会自动给添加注释)

    1、File-->settings-->Editor-->File and Code Templates-->Files

    我们选择Class文件(当然你要设置接口的还也可以选择Interface文件)

    (1)${NAME}:设置类名,与下面的${NAME}一样才能获取到创建的类名

    (2)TODO:代办事项的标记,一般生成类或方法都需要添加描述

    (3)${USER}、${DATE}、${TIME}:设置创建类的用户、创建的日期和时间,这些事IDEA内置的方法,还有一些其他的方法在绿色框标注的位置,比如你想添加项目名则可以使用${PROJECT_NAME}

    (4)1.0:设置版本号,一般新创建的类都是1.0版本,这里写死就可以了

    2、效果图展示

    二、设置方法注释模板

    IDEA还没有智能到自动为我们创建方法注释,这就是要我们手动为方法添加注释,使用Eclipse时我们生成注释的习惯是

    /**+Enter,这里我们也按照这种习惯来设置IDEA的方法注释

    1、File-->Settings-->Editor-->Live Templates

    (1)新建组:命名为userDefine

    (2)新建模板:命名为*

    因为IDEA生成注释的默认方式是:/*+模板名+快捷键(比如若设置模板名为add快捷键用Tab,则生成方式为

    /*add+Tab),如果不采用这样的生成方式IDEA中没有内容的方法将不可用,例如获取方法参数的methodParameters()、

    获取方法返回值的methodReturnType()

    (3)设置生成注释的快捷键

    (4)设置模板:模板内容如下

    注意第一行,只有一个*而不是/*

    在设置参数名时必须用${参数名}$的方式,否则第五步中读取不到你设置的参数名

    注意:下面这段是代码,可以直接复制的!可以直接复制的!可以直接复制的!不要再问我为什么都是图片了,留着眼睛干啥?

    *
     * @Author liu-miss
     * @Description //TODO $end$
     * @Date $time$ $date$
     * @Param $param$
     * @return $return$
     **/

    如果使用/*生成的模板注释将会是如下效果:所以我们要去掉最前面的/*

    (5)设置模板的应用场景

    点击模板页面最下方的警告,来设置将模板应用于那些场景,一般选择EveryWhere-->Java即可

    (如果曾经修改过,则显示为change而不是define)

    (6)设置参数的获取方式

    选择右侧的Edit variables按钮

    PS:第五步和第六步顺序不可颠倒,否则第六步将获取不到方法

    选择每个参数对应的获取方法(在下拉选择框中选择即可),网上有很多教程说获取param时使用脚本的方式,我试过使用脚本

    的方式不仅麻烦而且只能在方法内部使用注释时才能获取到参数

    (7)效果图

    创建方法,在方法上面写:/*+模板名+Enter-->/**+Enter

     

    展开全文
  • 【LeetCode】代码模板,刷题必会

    万次阅读 多人点赞 2019-10-02 08:58:09
    目录二分查找排序的写法BFS的写法DFS的写法回溯法树递归迭代前序遍历中序遍历后序遍历构建完全二叉树并查集前缀树图遍历Dijkstra算法Floyd-Warshall算法Bellman-Ford算法最小生成...,双指针模板动态规划状态搜索贪心...

    本文的目的是收集一些典型的题目,记住其写法,理解其思想,即可做到一通百通。欢迎大家提出宝贵意见!

    博主有算法题解的微信公众号啦,欢迎关注「负雪明烛」,持续更新算法题的解题思路:

    在这里插入图片描述

    二分查找

    最明显的题目就是34. Find First and Last Position of Element in Sorted Array

    花花酱的二分查找专题视频:https://www.youtube.com/watch?v=v57lNF2mb_s

    模板:

    区间定义:[l, r) 左闭右开

    其中f(m)函数代表找到了满足条件的情况,有这个条件的判断就返回对应的位置,如果没有这个条件的判断就是lowwer_bound和higher_bound.

    def binary_search(l, r):
        while l < r:
            m = l + (r - l) // 2
            if f(m):    # 判断找了没有,optional
                return m
            if g(m):
                r = m   # new range [l, m)
            else:
                l = m + 1 # new range [m+1, r)
        return l    # or not found
    

    lower bound: find index of i, such that A[i] >= x

    def lowwer_bound(self, nums, target):
        # find in range [left, right)
        left, right = 0, len(nums)
        while left < right:
            mid = left + (right - left) // 2
            if nums[mid] < target:
                left = mid + 1
            else:
                right = mid
        return left
    

    upper bound: find index of i, such that A[i] > x

    def higher_bound(self, nums, target):
        # find in range [left, right)
        left, right = 0, len(nums)
        while left < right:
            mid = left + (right - left) // 2
            if nums[mid] <= target:
                left = mid + 1
            else:
                right = mid
        return left
    

    比如,题目69. Sqrt(x)

    class Solution(object):
        def mySqrt(self, x):
            """
            :type x: int
            :rtype: int
            """
            left, right = 0, x + 1
            # [left, right)
            while left < right:
                mid = left + (right - left) // 2
                if mid ** 2 == x:
                    return mid
                if mid ** 2 < x:
                    left = mid + 1
                else:
                    right = mid
            return left - 1
    

    排序的写法

    C++的排序方法,使用sort并且重写comparator,如果需要使用外部变量,需要在中括号中放入&。

    题目451. Sort Characters By Frequency。

    class Solution {
    public:
        string frequencySort(string s) {
            unordered_map<char, int> m;
            for (char c : s) ++m[c];
            sort(s.begin(), s.end(), [&](char& a, char& b){
                return m[a] > m[b] || (m[a] == m[b] && a < b);
            });
            return s;
        }
    };
    

    BFS的写法

    下面的这个写法是在一个邻接矩阵中找出离某一个点距离是k的点。

    来自文章:【LeetCode】863. All Nodes Distance K in Binary Tree 解题报告(Python)

    # BFS
    bfs = [target.val]
    visited = set([target.val])
    for k in range(K):
        bfs = [y for x in bfs for y in conn[x] if y not in visited]
        visited |= set(bfs)
    return bfs
    
    1. Word Ladder

    在BFS中保存已走过的步,并把已经走的合法路径删除掉。

    class Solution(object):
        def ladderLength(self, beginWord, endWord, wordList):
            """
            :type beginWord: str
            :type endWord: str
            :type wordList: List[str]
            :rtype: int
            """
            wordset = set(wordList)
            bfs = collections.deque()
            bfs.append((beginWord, 1))
            while bfs:
                word, length = bfs.popleft()
                if word == endWord:
                    return length
                for i in range(len(word)):
                    for c in "abcdefghijklmnopqrstuvwxyz":
                        newWord = word[:i] + c + word[i + 1:]
                        if newWord in wordset and newWord != word:
                            wordset.remove(newWord)
                            bfs.append((newWord, length + 1))
            return 0
    

    778. Swim in Rising Water

    使用优先级队列来优先走比较矮的路,最后保存最高的那个格子的高度。

    class Solution(object):
        def swimInWater(self, grid):
            """
            :type grid: List[List[int]]
            :rtype: int
            """
            n = len(grid)
            visited, pq = set((0, 0)), [(grid[0][0], 0, 0)]
            res = 0
            while pq:
                T, i, j = heapq.heappop(pq)
                res = max(res, T)
                directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]
                if i == j == n - 1:
                    break
                for dir in directions:
                    x, y = i + dir[0], j + dir[1]
                    if x < 0 or x >= n or y < 0 or y >= n or (x, y) in visited:
                        continue
                    heapq.heappush(pq, (grid[x][y], x, y))
                    visited.add((x, y))
            return res
    

    847. Shortest Path Visiting All Nodes

    需要找出某顶点到其他顶点的最短路径。出发顶点不是确定的,每个顶点有可能访问多次。使用N位bit代表访问过的顶点的状态。如果到达了最终状态,那么现在步数就是所求。这个题把所有的节点都放入了起始队列中,相当于每次都是所有的顶点向前走一步。

    class Solution(object):
        def shortestPathLength(self, graph):
            """
            :type graph: List[List[int]]
            :rtype: int
            """
            N = len(graph)
            que = collections.deque()
            step = 0
            goal = (1 << N) - 1
            visited = [[0 for j in range(1 << N)] for i in range(N)]
            for i in range(N):
                que.append((i, 1 << i))
            while que:
                s = len(que)
                for i in range(s):
                    node, state = que.popleft()
                    if state == goal:
                        return step
                    if visited[node][state]:
                        continue
                    visited[node][state] = 1
                    for nextNode in graph[node]:
                        que.append((nextNode, state | (1 << nextNode)))
                step += 1
            return step
    

    429. N-ary Tree Level Order Traversal多叉树的层次遍历,这个BFS写法我觉得很经典。适合记忆。

    """
    # Definition for a Node.
    class Node(object):
        def __init__(self, val, children):
            self.val = val
            self.children = children
    """
    class Solution(object):
        def levelOrder(self, root):
            """
            :type root: Node
            :rtype: List[List[int]]
            """
            res = []
            que = collections.deque()
            que.append(root)
            while que:
                level = []
                size = len(que)
                for _ in range(size):
                    node = que.popleft()
                    if not node:
                        continue
                    level.append(node.val)
                    for child in node.children:
                        que.append(child)
                if level:
                    res.append(level)
            return res
    

    DFS的写法

    329. Longest Increasing Path in a Matrix

    417. Pacific Atlantic Water Flow

    778. Swim in Rising Water

    二分查找+DFS

    class Solution(object):
        def swimInWater(self, grid):
            """
            :type grid: List[List[int]]
            :rtype: int
            """
            n = len(grid)
            left, right = 0, n * n - 1
            while left <= right:
                mid = left + (right - left) / 2
                if self.dfs([[False] * n for _ in range(n)], grid, mid, n, 0, 0):
                    right = mid - 1
                else:
                    left = mid + 1
            return left
            
        def dfs(self, visited, grid, mid, n, i, j):
            visited[i][j] = True
            if i == n - 1 and j == n - 1:
                return True
            directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]
            for dir in directions:
                x, y = i + dir[0], j + dir[1]
                if x < 0 or x >= n or y < 0 or y >= n or visited[x][y] or max(mid, grid[i][j]) != max(mid, grid[x][y]):
                    continue
                if self.dfs(visited, grid, mid, n, x, y):
                    return True
            return False
    

    回溯法

    下面这个题使用了回溯法,但是写的不够简单干练,遇到更好的解法的时候,要把这个题进行更新。

    这个回溯思想,先去添加一个新的状态,看在这个状态的基础上,能不能找结果,如果找不到结果的话,那么就回退,即把这个结果和访问的记录给去掉。这个题使用了return True的方法让我们知道已经找出了结果,所以不用再递归了。

    753. Cracking the Safe

    class Solution(object):
        def crackSafe(self, n, k):
            """
            :type n: int
            :type k: int
            :rtype: str
            """
            res = ["0"] * n
            size = k ** n
            visited = set()
            visited.add("".join(res))
            if self.dfs(res, visited, size, n, k):
                return "".join(res)
            return ""
            
        def dfs(self, res, visited, size, n, k):
            if len(visited) == size:
                return True
            node = "".join(res[len(res) - n + 1:])
            for i in range(k):
                node = node + str(i)
                if node not in visited:
                    res.append(str(i))
                    visited.add(node)
                    if self.dfs(res, visited, size, n, k):
                        return True
                    res.pop()
                    visited.remove(node)
                node = node[:-1]
    

    312. Burst Balloons

    class Solution(object):
        def maxCoins(self, nums):
            """
            :type nums: List[int]
            :rtype: int
            """
            n = len(nums)
            nums.insert(0, 1)
            nums.append(1)
            c = [[0] * (n + 2) for _ in range(n + 2)]
            return self.dfs(nums, c, 1, n)
            
        def dfs(self, nums, c, i, j):
            if i > j: return 0
            if c[i][j] > 0: return c[i][j]
            if i == j: return nums[i - 1] * nums[i] * nums[i + 1]
            res = 0
            for k in range(i, j + 1):
                res = max(res, self.dfs(nums, c, i, k - 1) + nums[i - 1] * nums[k] * nums[j + 1] + self.dfs(nums, c, k + 1, j))
            c[i][j] = res
            return c[i][j]
    
    class Solution {
    public:
        int countArrangement(int N) {
            int res = 0;
            vector<int> visited(N + 1, 0);
            helper(N, visited, 1, res);
            return res;
        }
    private:
        void helper(int N, vector<int>& visited, int pos, int& res) {
            if (pos > N) {
                res++;
                return;
            }
            for (int i = 1; i <= N; i++) {
                if (visited[i] == 0 && (i % pos == 0 || pos % i == 0)) {
                    visited[i] = 1;
                    helper(N, visited, pos + 1, res);
                    visited[i] = 0;
                }
            }
        }
    };
    

    如果需要保存路径的回溯法:

    class Solution {
    public:
        vector<vector<int>> permute(vector<int>& nums) {
            const int N = nums.size();
            vector<vector<int>> res;
            vector<int> path;
            vector<int> visited(N, 0);
            dfs(nums, 0, visited, res, path);
            return res;
        }
    private:
        void dfs(vector<int>& nums, int pos, vector<int>& visited, vector<vector<int>>& res, vector<int>& path) {
            const int N = nums.size();
            if (pos == N) {
                res.push_back(path);
                return;
            }
            for (int i = 0; i < N; i++) {
                if (!visited[i]) {
                    visited[i] = 1;
                    path.push_back(nums[i]);
                    dfs(nums, pos + 1, visited, res, path);
                    path.pop_back();
                    visited[i] = 0;
                }
            }
        }
    };
    

    递归

    617. Merge Two Binary Trees把两个树重叠,重叠部分求和,不重叠部分是两个树不空的节点。

    class Solution:
        def mergeTrees(self, t1, t2):
            if not t2:
                return t1
            if not t1:
                return t2
            newT = TreeNode(t1.val + t2.val)
            newT.left = self.mergeTrees(t1.left, t2.left)
            newT.right = self.mergeTrees(t1.right, t2.right)
            return newT
    

    迭代

    226. Invert Binary Tree

    # Definition for a binary tree node.
    # class TreeNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    class Solution(object):
        def invertTree(self, root):
            """
            :type root: TreeNode
            :rtype: TreeNode
            """
            stack = []
            stack.append(root)
            while stack:
                node = stack.pop()
                if not node:
                    continue
                node.left, node.right = node.right, node.left
                stack.append(node.left)
                stack.append(node.right)
            return root
    

    前序遍历

    144. Binary Tree Preorder Traversal

    迭代写法:

    # Definition for a binary tree node.
    # class TreeNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    class Solution(object):
        def preorderTraversal(self, root):
            """
            :type root: TreeNode
            :rtype: List[int]
            """
            if not root: return []
            res = []
            stack = []
            stack.append(root)
            while stack:
                node = stack.pop()
                if not node:
                    continue
                res.append(node.val)
                stack.append(node.right)
                stack.append(node.left)
            return res
    
    

    中序遍历

    94. Binary Tree Inorder Traversal

    迭代写法:

    # Definition for a binary tree node.
    # class TreeNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    class Solution(object):
        def inorderTraversal(self, root):
            """
            :type root: TreeNode
            :rtype: List[int]
            """
            stack = []
            answer = []
            while True:
                while root:
                    stack.append(root)
                    root = root.left
                if not stack:
                    return answer
                root = stack.pop()
                answer.append(root.val)
                root = root.right
    

    后序遍历

    145. Binary Tree Postorder Traversal

    迭代写法如下:

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     TreeNode *left;
     *     TreeNode *right;
     *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
     * };
     */
    class Solution {
    public:
        vector<int> postorderTraversal(TreeNode* root) {
            vector<int> res;
            if (!root) return res;
            stack<TreeNode*> st;
            st.push(root);
            while (!st.empty()) {
                TreeNode* node = st.top(); st.pop();
                if (!node) continue;
                res.push_back(node->val);
                st.push(node->left);
                st.push(node->right);
            }
            reverse(res.begin(), res.end());
            return res;
        }
    };
    

    构建完全二叉树

    完全二叉树是每一层都满的,因此找出要插入节点的父亲节点是很简单的。如果用数组tree保存着所有节点的层次遍历,那么新节点的父亲节点就是tree[(N -1)/2],N是未插入该节点前的树的元素个数。
    构建树的时候使用层次遍历,也就是BFS把所有的节点放入到tree里。插入的时候直接计算出新节点的父亲节点。获取root就是数组中的第0个节点。

    919. Complete Binary Tree Inserter

    # Definition for a binary tree node.
    # class TreeNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    class CBTInserter(object):
    
        def __init__(self, root):
            """
            :type root: TreeNode
            """
            self.tree = list()
            queue = collections.deque()
            queue.append(root)
            while queue:
                node = queue.popleft()
                self.tree.append(node)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
    
        def insert(self, v):
            """
            :type v: int
            :rtype: int
            """
            _len = len(self.tree)
            father = self.tree[(_len - 1) / 2]
            node = TreeNode(v)
            if not father.left:
                father.left = node
            else:
                father.right = node
            self.tree.append(node)
            return father.val
            
    
        def get_root(self):
            """
            :rtype: TreeNode
            """
            return self.tree[0]
    
    
    # Your CBTInserter object will be instantiated and called as such:
    # obj = CBTInserter(root)
    # param_1 = obj.insert(v)
    # param_2 = obj.get_root()
    

    并查集

    不包含rank的话,代码很简短,应该背会。

    1. Accounts Merge
      https://leetcode.com/articles/accounts-merge/
    class DSU:
        def __init__(self):
            self.par = range(10001)
    
        def find(self, x):
            if x != self.par[x]:
                self.par[x] = self.find(self.par[x])
            return self.par[x]
        
        def union(self, x, y):
            self.par[self.find(x)] = self.find(y)
        
        def same(self, x, y):
            return self.find(x) == self.find(y)
    

    C++版本如下:

    vector<int> map_; //i的parent,默认是i
    int f(int a) {
        if (map_[a] == a)
            return a;
        return f(map_[a]);
    }
    void u(int a, int b) {
        int pa = f(a);
        int pb = f(b);
        if (pa == pb)
            return;
        map_[pa] = pb;
    }
    

    包含rank的,这里的rank表示树的高度:

    684. Redundant Connection

    class DSU(object):
        def __init__(self):
            self.par = range(1001)
            self.rnk = [0] * 1001
    
        def find(self, x):
            if self.par[x] != x:
                self.par[x] = self.find(self.par[x])
            return self.par[x]
    
        def union(self, x, y):
            xr, yr = self.find(x), self.find(y)
            if xr == yr:
                return False
            elif self.rnk[xr] < self.rnk[yr]:
                self.par[xr] = yr
            elif self.rnk[xr] > self.rnk[yr]:
                self.par[yr] = xr
            else:
                self.par[yr] = xr
                self.rnk[xr] += 1
            return True
    

    另外一种rank方法是,保存树中节点的个数。

    547. Friend Circles,代码如下:

    class Solution(object):
        def findCircleNum(self, M):
            """
            :type M: List[List[int]]
            :rtype: int
            """
            dsu = DSU()
            N = len(M)
            for i in range(N):
                for j in range(i, N):
                    if M[i][j]:
                        dsu.u(i, j)
            res = 0
            for i in range(N):
                if dsu.f(i) == i:
                    res += 1
            return res
            
    class DSU(object):
        def __init__(self):
            self.d = range(201)
            self.r = [0] * 201
            
        def f(self, a):
            return a if a == self.d[a] else self.f(self.d[a])
        
        def u(self, a, b):
            pa = self.f(a)
            pb = self.f(b)
            if (pa == pb):
                return
            if self.r[pa] < self.r[pb]:
                self.d[pa] = pb
                self.r[pb] += self.r[pa]
            else:
                self.d[pb] = pa
                self.r[pa] += self.r[pb]
    

    前缀树

    前缀树的题目可以使用字典解决,代码还是需要背一下的,C++版本的前缀树如下:

    208. Implement Trie (Prefix Tree)这个题是纯考Trie的。参考代码如下:

    class TrieNode {
    public:
        vector<TrieNode*> child;
        bool isWord;
        TrieNode() : isWord(false), child(26, nullptr) {
        }
        ~TrieNode() {
            for (auto& c : child)
                delete c;
        }
    };
    
    class Trie {
    public:
        /** Initialize your data structure here. */
        Trie() {
            root = new TrieNode();
        }
        
        /** Inserts a word into the trie. */
        void insert(string word) {
            TrieNode* p = root;
            for (char a : word) {
                int i = a - 'a';
                if (!p->child[i])
                    p->child[i] = new TrieNode();
                p = p->child[i];
            }
            p->isWord = true;
        }
        
        /** Returns if the word is in the trie. */
        bool search(string word) {
            TrieNode* p = root;
            for (char a : word) {
                int i = a - 'a';
                if (!p->child[i])
                    return false;
                p = p->child[i];
            }
            return p->isWord;
        }
        
        /** Returns if there is any word in the trie that starts with the given prefix. */
        bool startsWith(string prefix) {
            TrieNode* p = root;
            for (char a : prefix) {
                int i = a - 'a';
                if (!p->child[i])
                    return false;
                p = p->child[i];
            }
            return true;
        }
    private:
        TrieNode* root;
    };
    
    /**
     * Your Trie object will be instantiated and called as such:
     * Trie obj = new Trie();
     * obj.insert(word);
     * bool param_2 = obj.search(word);
     * bool param_3 = obj.startsWith(prefix);
     */
    

    677. Map Sum Pairs

    class MapSum {
    public:
        /** Initialize your data structure here. */
        MapSum() {}
        
        void insert(string key, int val) {
            int inc = val - vals_[key];
            Trie* p = &root;
            for (const char c : key) {
                if (!p->children[c])
                    p->children[c] = new Trie();
                p->children[c]->sum += inc;
                p = p->children[c];
            }
            vals_[key] = val;
        }
        
        int sum(string prefix) {
            Trie* p = &root;
            for (const char c : prefix) {
                if (!p->children[c])
                    return 0;
                p = p->children[c];
            }
            return p->sum;
        }
    private:
        struct Trie {
            Trie():children(128, nullptr), sum(0){}
            ~Trie(){
                for (auto child : children)
                    if (child) delete child;
                children.clear();
            }
            vector<Trie*> children;
            int sum;
        };
        
        Trie root;
        unordered_map<string, int> vals_;
    };
    

    图遍历

    743. Network Delay Time这个题很详细。

    Dijkstra算法

    时间复杂度是O(N ^ 2 + E),空间复杂度是O(N+E).

    class Solution:
        def networkDelayTime(self, times, N, K):
            """
            :type times: List[List[int]]
            :type N: int
            :type K: int
            :rtype: int
            """
            K -= 1
            nodes = collections.defaultdict(list)
            for u, v, w in times:
                nodes[u - 1].append((v - 1, w))
            dist = [float('inf')] * N
            dist[K] = 0
            done = set()
            for _ in range(N):
                smallest = min((d, i) for (i, d) in enumerate(dist) if i not in done)[1]
                for v, w in nodes[smallest]:
                    if v not in done and dist[smallest] + w < dist[v]:
                        dist[v] = dist[smallest] + w
                done.add(smallest)
            return -1 if float('inf') in dist else max(dist)
    

    Floyd-Warshall算法

    时间复杂度O(n^3), 空间复杂度O(n^2)。

    class Solution:
        def networkDelayTime(self, times, N, K):
            """
            :type times: List[List[int]]
            :type N: int
            :type K: int
            :rtype: int
            """
            d = [[float('inf')] * N for _ in range(N)]
            for time in times:
                u, v, w = time[0] - 1, time[1] - 1, time[2]
                d[u][v] = w
            for i in range(N):
                d[i][i] = 0
            for k in range(N):
                for i in range(N):
                    for j in range(N):
                        d[i][j] = min(d[i][j], d[i][k] + d[k][j])
            return -1 if float('inf') in d[K - 1] else max(d[K - 1])
    

    Bellman-Ford算法

    时间复杂度O(ne), 空间复杂度O(n)

    class Solution:
        def networkDelayTime(self, times, N, K):
            """
            :type times: List[List[int]]
            :type N: int
            :type K: int
            :rtype: int
            """
            dist = [float('inf')] * N
            dist[K - 1] = 0
            for i in range(N):
                for time in times:
                    u = time[0] - 1
                    v = time[1] - 1
                    w = time[2]
                    dist[v] = min(dist[v], dist[u] + w)
            return -1 if float('inf') in dist else max(dist)
    

    最小生成树

    1135. Connecting Cities With Minimum Cost

    Kruskal算法

    class Solution {
    public:
        static bool cmp(vector<int> & a,vector<int> & b){
            return a[2] < b[2];
        }
        
        int find(vector<int> & f,int x){
            while(x != f[x]){
                x = f[x];
            }
            return x;
        }
        
        bool uni(vector<int> & f,int x,int y){
            int x1 = find(f,x);
            int y1 = find(f,y);
            f[x1] = y1;
            
            return true;
        }
        
        int minimumCost(int N, vector<vector<int>>& conections) {
            int ans = 0;
            int count = 0;
            vector<int> father(N+1,0);
            
            sort(conections.begin(),conections.end(),cmp);
            for(int i = 0;i <= N; ++i){
                father[i] = i;
            }
            
            for(auto conect : conections){
                if(find(father,conect[0]) != find(father,conect[1])){
                    count++;
                    ans += conect[2];
                    uni(father,conect[0],conect[1]);
                    if(count == N-1){
                        return ans;
                    }
                }
            }
            
            return -1;
        }
    };
    

    Prim算法

    struct cmp {
        bool operator () (const vector<int> &a, const vector<int> &b) {
            return a[2] > b[2];
        }
    };
    
    class Solution {
    public:    
        int minimumCost(int N, vector<vector<int>>& conections) {
            int ans = 0;
            int selected = 0;
            vector<vector<pair<int,int>>> edgs(N+1,vector<pair<int,int>>());
            priority_queue<vector<int>,vector<vector<int>>,cmp> pq;
            vector<bool> visit(N+1,false);
            
            /*initial*/
            for(auto re : conections){
                edgs[re[0]].push_back(make_pair(re[1],re[2]));
                edgs[re[1]].push_back(make_pair(re[0],re[2]));
            }
            
            if(edgs[1].size() == 0){
                return -1;
            }
            
            /*kruskal*/
            selected = 1;
            visit[1] = true;
            for(int i = 0;i < edgs[1].size(); ++i){
                pq.push(vector<int>({1,edgs[1][i].first,edgs[1][i].second}));
            }
            
            while(!pq.empty()){
                vector<int> curr = pq.top();
                pq.pop();
                
                if(!visit[curr[1]]){
                    visit[curr[1]] = true;
                    ans += curr[2];
                    for(auto e : edgs[curr[1]]){
                        pq.push(vector<int>({curr[1],e.first,e.second}));
                    }
                    selected++;
                    if(selected == N){
                        return ans;
                    }
                }
            }
            
            return -1;
        }
    };
    

    拓扑排序

    BFS方式:

    class Solution(object):
        def canFinish(self, N, prerequisites):
            """
            :type N,: int
            :type prerequisites: List[List[int]]
            :rtype: bool
            """
            graph = collections.defaultdict(list)
            indegrees = collections.defaultdict(int)
            for u, v in prerequisites:
                graph[v].append(u)
                indegrees[u] += 1
            for i in range(N):
                zeroDegree = False
                for j in range(N):
                    if indegrees[j] == 0:
                        zeroDegree = True
                        break
                if not zeroDegree: return False
                indegrees[j] = -1
                for node in graph[j]:
                    indegrees[node] -= 1
            return True                
    

    DFS方式:

    class Solution(object):
        def canFinish(self, N, prerequisites):
            """
            :type N,: int
            :type prerequisites: List[List[int]]
            :rtype: bool
            """
            graph = collections.defaultdict(list)
            for u, v in prerequisites:
                graph[u].append(v)
            # 0 = Unknown, 1 = visiting, 2 = visited
            visited = [0] * N
            for i in range(N):
                if not self.dfs(graph, visited, i):
                    return False
            return True
            
        # Can we add node i to visited successfully?
        def dfs(self, graph, visited, i):
            if visited[i] == 1: return False
            if visited[i] == 2: return True
            visited[i] = 1
            for j in graph[i]:
                if not self.dfs(graph, visited, j):
                    return False
            visited[i] = 2
            return True
    

    如果需要保存拓扑排序的路径:

    BFS方式:

    class Solution(object):
        def findOrder(self, numCourses, prerequisites):
            """
            :type numCourses: int
            :type prerequisites: List[List[int]]
            :rtype: List[int]
            """
            graph = collections.defaultdict(list)
            indegrees = collections.defaultdict(int)
            for u, v in prerequisites:
                graph[v].append(u)
                indegrees[u] += 1
            path = []
            for i in range(numCourses):
                zeroDegree = False
                for j in range(numCourses):
                    if indegrees[j] == 0:
                        zeroDegree = True
                        break
                if not zeroDegree:
                    return []
                indegrees[j] -= 1
                path.append(j)
                for node in graph[j]:
                    indegrees[node] -= 1
            return path
    

    DFS方式:

    class Solution(object):
        def findOrder(self, numCourses, prerequisites):
            """
            :type numCourses: int
            :type prerequisites: List[List[int]]
            :rtype: List[int]
            """
            graph = collections.defaultdict(list)
            for u, v in prerequisites:
                graph[u].append(v)
            # 0 = Unknown, 1 = visiting, 2 = visited
            visited = [0] * numCourses
            path = []
            for i in range(numCourses):
                if not self.dfs(graph, visited, i, path):
                    return []
            return path
        
        def dfs(self, graph, visited, i, path):
            if visited[i] == 1: return False
            if visited[i] == 2: return True
            visited[i] = 1
            for j in graph[i]:
                if not self.dfs(graph, visited, j, path):
                    return False
            visited[i] = 2
            path.append(i)
            return True
    

    207. Course Schedule

    210. Course Schedule II

    310. Minimum Height Trees

    双指针

    这是一个模板,里面的map如果是双指针范围内的字符串字频的话,增加和减少的方式如下。

    int findSubstring(string s){
            vector<int> map(128,0);
            int counter; // check whether the substring is valid
            int begin=0, end=0; //two pointers, one point to tail and one  head
            int d; //the length of substring
    
            for() { /* initialize the hash map here */ }
    
            while(end<s.size()){
    
                if(map[s[end++]]++ ?){  /* modify counter here */ }
    
                while(/* counter condition */){ 
                     
                     /* update d here if finding minimum*/
    
                    //increase begin to make it invalid/valid again
                    
                    if(map[s[begin++]]-- ?){ /*modify counter here*/ }
                }  
    
                /* update d here if finding maximum*/
            }
            return d;
      }
    

    424. 替换后的最长重复字符

    这个题的map是t的字频,所以使用map更方式和上是相反的。

    class Solution(object):
        def characterReplacement(self, s, k):
            N = len(s)
            left, right = 0, 0 # [left, right] 都包含
            counter = collections.Counter()
            res = 0
            while right < N:
                counter[s[right]] += 1
                maxCnt = counter.most_common(1)[0][1]
                while right - left + 1 - maxCnt > k:
                    counter[s[left]] -= 1
                    left += 1
                res = max(res, right - left + 1)
                right += 1
            return res
    

    动态规划

    状态搜索

    688. Knight Probability in Chessboard

    62. Unique Paths

    63. Unique Paths II

    913. Cat and Mouse

    576. Out of Boundary Paths

    class Solution(object):
        def findPaths(self, m, n, N, i, j):
            """
            :type m: int
            :type n: int
            :type N: int
            :type i: int
            :type j: int
            :rtype: int
            """
            dp = [[0] * n for _ in range(m)]
            for s in range(1, N + 1):
                curStatus = [[0] * n for _ in range(m)]
                for x in range(m):
                    for y in range(n):
                        v1 = 1 if x == 0 else dp[x - 1][y]
                        v2 = 1 if x == m - 1 else dp[x + 1][y]
                        v3 = 1 if y == 0 else dp[x][y - 1]
                        v4 = 1 if y == n - 1 else dp[x][y + 1]
                        curStatus[x][y] = (v1 + v2 + v3 + v4) % (10**9 + 7)
                dp = curStatus
            return dp[i][j]
    

    贪心

    贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来最好的选择。也就是说,不从整体最优上加以考虑,他所作出的是在某种意义上的局部最优解。贪心算法和动态规划算法都是由局部最优导出全局最优,这里不得不比较下二者的区别

    贪心算法:
    1.贪心算法中,作出的每步贪心决策都无法改变,因为贪心策略是由上一步的最优解推导下一步的最优解,而上一部之前的最优解则不作保留。
    2.由(1)中的介绍,可以知道贪心法正确的条件是:每一步的最优解一定包含上一步的最优解

    动态规划算法:
    1.全局最优解中一定包含某个局部最优解,但不一定包含前一个局部最优解,因此需要记录之前的所有最优解
    2.动态规划的关键是状态转移方程,即如何由以求出的局部最优解来推导全局最优解
    3.边界条件:即最简单的,可以直接得出的局部最优解

    贪心是个思想,没有统一的模板。

    展开全文
  • IntelliJ IDEA 自定义方法注解模板

    万次阅读 多人点赞 2017-08-02 18:04:36
    刚上手大概有一天,就知道它为啥取名为 intelli(智能化)了,确实很智能,这还是一些小小的细节,当然idea也有它不足之处,就是我们今天要讲的“自定义方法注解模板”,类注解模板可以很简单的设置,这里我就不重复...

     

    最近没啥事开始正式用Eclipse 转入 idea工具阵营,毕竟有70%的开发者在使用idea开发,所以它的魅力可想而知。刚上手大概有一天,就知道它为啥取名为 intelli(智能化)了,确实很智能,这还是一些小小的细节,当然idea也有它不足之处,就是我们今天要讲的“自定义方法注解模板”,类注解模板可以很简单的设置,这里我就不重复,而网上很多关于自定义方法注解模板的文章大多是抄袭获取转发根本自己就没有验证,本文经过自己亲自验证有效

     

    1. File->settings->Editor->Live Templates


       
    2. 点击右上角的绿色+号,然后选择template group ,然后输入group的name,随便输入就好了:myGroup。然后点ok


       
    3. 选中刚才创建的myGroup,然后再次点击右侧的绿色+,这次选择的是第一个1. Live Template。取名为*,取名可以随便,只是个人觉得方便,你可以取别的。
       

       
    4. 配置模板,下面是我的模板,大家仔细看我的模板开头是*而不是/*,这就是关键所在。
       
      *
       *  
       * 
       * @author chenmc
       * @date $date$ $time$
       * @param $params$
       * @return $returns$
       */
      注意:只有当变量被$$包围时 右侧的Edit variables才可以点击哦。

       
    5. 再编辑好模板之后就只为参数添加$$添加变量,点击右侧的 Editor variables,


       
    6. 完成之后点击Apply然后点击OK,注意了,重点的地方,在你的方法上输入 /*然后加上模板的名称*,这就是我为什么不取字母而取名为*,因为这样很快速,再按Tab键(注意啊不是按Enter键,而是按Tab键)就会出现你想要的注释了,很多教程是直接输入模板名称按tab键,但是这种方法的@param和@return是获取不到的,再重复一遍正确的方式:/** 然后按Tab键;如果你取名为abc那就是  /*abc 然后按Tab。效果如下:


       
    7. 但是还有一个问题,细心的读者会发现在@param这个参数上报错了,这是因为idea强大的检查功能,有两种解决办法:
       
      第一种:File->settings->Editor->Inspections->javadoc issues下面第四项将红色 Error改为黄色Warning即可
      第二种:点击idea的右下角的人头图像,然后选择高亮级别,调为Syntax模式即可



      至此已大功告成了,希望能帮到大家!

      对本教程如有疑问请关注微信公众号:裸睡的猪,获取帮助!!!

       
    展开全文
  • 【VUE】vue后台常用模板

    万次阅读 多人点赞 2019-04-11 15:30:13
    vue后台常用模板: element文档: http://element-cn.eleme.io/#/zh-CN/component/installation vue API: https://cn.vuejs.org/v2/api/ 以下是在下收集的三个常用的vue模板 1、vue-manage-system git地址:...

    vue后台常用模板:

    element文档: http://element-cn.eleme.io/#/zh-CN/component/installation
    vue API: https://cn.vuejs.org/v2/api/

    以下是在下收集的三个常用的vue模板

    1、vue-manage-system

    git地址:https://github.com/lin-xin/vue-manage-system
    线上地址: https://lin-xin.gitee.io/example/work/#/login
    模板如图:
    在这里插入图片描述


    2、vue-element-admin
    git地址:https://github.com/PanJiaChen/vue-element-admin
    国际化版本:https://github.com/PanJiaChen/vue-element-admin/tree/i18n

    中文线上预览:https://panjiachen.github.io/vue-element-admin/#/dashboard

    IE兼容处理:参考文章
    模板如图:
    在这里插入图片描述


    3、vuejs 和 element 搭建的一个后台管理界面

    相关技术:
    vuejs2.0:渐进式JavaScript框架,易用、灵活、高效,似乎任何规模的应用都适用。
    element:基于vuejs2.0的ui组件库。
    vue-router:一般单页面应用spa都要用到的前端路由。
    vuex:Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。

    线上地址:https://taylorchen709.github.io/vue-admin/#/login
    git地址:https://github.com/taylorchen709/vue-admin
    模板如图:
    在这里插入图片描述
    使用:

    install dependencies

    npm install
    serve with hot reload at localhost:8081

    npm run dev
    build for production with minification

    npm run build


    4、基于Vue实现后台系统权限控制

    基于Vue.js 2.x系列 + Element UI 的后台系统权限控制

    git地址:https://github.com/mgbq/vue-permission
    线上地址:https://mgbq.github.io/vue-permission/#/dashboard/dashboard

    使用参考博客: https://blog.csdn.net/qq_32340877/article/details/79416344
    在这里插入图片描述

    展开全文
  • hostiko模板-WHMCS自适应模板-略站网

    万次阅读 2021-07-19 02:55:46
    模板自带暗/夜模式,附带购物车功能 下载地址: https://lvezhan.com/archives/369
  • C++函数模板模板函数)详解

    万次阅读 多人点赞 2019-07-04 16:03:01
    C++函数模板模板函数)详解定义用法:函数模板的原理延申用法2.1为什么需要类模板2.2单个类模板语法2.3继承中的类模板语法案例1:案例2:2.4类模板的基础语法2.5类模板语法知识体系梳理1.所有的类模板函数写在类的...
  • C++模板、类模板、函数模板详解都在这里了

    万次阅读 多人点赞 2019-07-13 21:45:39
    C++模板、类模板、函数模板详解一、引言二、函数模板1、定义2、调用3、多个虚类型三、类模板1、定义2、调用四、类的函数模板五、类作为数据类型传入六、类模板与继承七、类模板与友元 一、引言 在写排序算法时,如果...
  • 适合程序员的简历模板

    万次阅读 多人点赞 2018-08-26 19:56:34
    今天找了好多简历的模板,分享一下 这个链接里序号是8,23,34,37的,这几个都挺适合程序员。 链接:https://pan.baidu.com/s/1o8rCjwA#list/path=%2F 密码:5dky 需要其他的可以点击下面的链接 知乎上的简历...
  • jsp模板 jsp模板 jsp模板jsp模板jsp模板

    热门讨论 2009-12-01 18:08:11
    jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp模板jsp...
  • 易语言模板 易语言模易语言模板 易语言模板 易语言模板板 易语言模板易语言模板 易语言模板 易语言模板
  • ACM模板(满注释模板!)

    万次阅读 多人点赞 2020-04-13 22:00:52
    ACM模板,不同于其他大佬的是我这个模板是满注释的!哪怕是小白的你考场上都能快速上手算法,每一句都有注释帮你快速理解,方便对模板根据题意的修改
  • 132套html模块 包含企业模板和后台模板

    千次下载 热门讨论 2013-06-08 00:02:23
    html模块 包含企业模板和后台模板,样式多种多样,我们前台程序员开发的必备工具
  • 模板模板

    万次阅读 多人点赞 2019-07-04 21:10:42
    模板模板类 所谓类模板,实际上是建立一个通用类,其数据成员、成员函数的返回值类型和形参类型不具体指定,用一个虚拟的类型来代表。使用类模板定义对象时,系统会实参的类型来取代类模板中虚拟类型从而实现了...
  • 学生信息管理系统模板,全套模板,DIV+CSS布局,清新简约。有个人中心、我的信息、班级信息、短信息、学院通知、我的异议、教务中心、我的报考、我的成绩、我的书籍、学习中心、资料下载、学习历程、财务中心、我的...
  • 设计模式 - 行为型设计模式 - 模板方法模式(Java)

    万次阅读 多人点赞 2019-02-26 20:29:04
    protected void end() { } } 模板方法中调用了 3 个方法,其中 apply() 是抽象方法,子类必须实现它,其实模板方法中有几个抽象方法完全是自由的,我们也可以将三个方法都设置为抽象方法,让子类来实现。...
  • 基于React+antd的后台管理模板(可预览)

    万次阅读 多人点赞 2018-08-05 13:42:53
    自己利用业余时间,基于React+antd写了一个后台管理模板。主要是熟悉antd组件和React,页面主要还是展示页面,不涉及后台交互。 特点: 我用
  • 精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板精美 ppt 模板 模板...
  • WordPress主题NDNAV网址导航网站模板

    万次阅读 2021-02-14 18:59:52
    wordpress主题NDNAV网址导航网站模板是一款简约大气昼夜wordpress免费导航主题,这款主题界面、功能都非常简洁。作者把这款定位为简约导航主题,所以这款wordpress导航主题没有过多的花里胡哨功能,也保证了这款主题...
  • 网站后台管理模板HTML模板

    千次下载 热门讨论 2011-08-30 21:01:13
    网站后台管理模板HTML模板,网页模板,标准w3c验证模板
  • idea快速开发之代码模板的使用方法

    万次阅读 多人点赞 2020-05-04 22:01:06
    学习时,使用IDEA编写Java的时候,经常使用到不少代码模板,熟悉代码模板可以提高编码效率。以下介绍开发时经常使用到的代码模板。 idea代码模板使用教程目录一、 常用代码模板1.1 使用代码模板1.2 常见的代码模板二...
  • HTML邮件模板编写规则,编写邮件HTML模板

    万次阅读 热门讨论 2018-06-07 22:59:37
    工作中遇到需要发邮件模板给客户发送凭证,踩坑踩出来一下规则: 1.所有样式必须行内,否则不起作用 大部分邮件客户端中不支持使用外置css样式,最好使用内联样式 2.所有布局必须使用table,复杂布局使用...
  • JSP网页模板JSP网页模板JSP网页模板

    热门讨论 2009-06-29 16:09:15
    JSP网页模板JSP网页模板JSP网页模板JSP网页模板JSP网页模板JSP网页模板JSP网页模板JSP网页模板JSP网页模板
  • 纯HTML个人简历模板代码

    万次阅读 多人点赞 2019-08-23 16:37:02
    <html> <body background=http://p1.so.qhmsg.com/t01ed5a885549b6bf3b.jpg> <table border="1" align="center" cellpadding="10" width="800">...th colspan="7" bgcolor="B...
  • xmind 模板

    千次下载 热门讨论 2013-02-04 16:49:18
    xmind模板 灵感来的时候赶紧记录下来吧
  • C++模板:函数模板

    万次阅读 2018-09-10 23:40:52
    函数模板: 函数模板: 我们看这段代码,compare是一个函数名还是一个模板名?其实他是一个模板名。如果要把他看成一函数来使用,就要用一个类型来实例化这个模板,在使用时可以给其后尖括号中加上要使用的...
  • 模板
  • 网页设计个人模板 商业模板 个人模板 商业模板 个人模板 商业模板 个人模板 商业模板
  • Halcon创建模板并进行模板匹配

    万次阅读 2018-10-19 19:36:15
    在进行图像处理时,很多时候创建模板并通过匹配模板进行图像基准点的分析能大大提高ROI的选取准确度和效率。 下面通过实例来讲述模板匹配的快速学习应用。 首先创建模板 先读取图像,对读取的图像创建模板并...
  • 在C++11之前,类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能,允许模板定义中包含0到任意个模板参数,这就是可变参数模板。可变参数模板的加入使得C++11的功能变得更加强大,而由此也带来了许多...
  • Zabbix 模板

    万次阅读 2021-03-13 17:13:44
    **## Zabbix 模板 1、官方的 share 分享网站 https://share.zabbix.com/zabbix-tools-and-utilities 例如:我们要实现监控Nginx ,我们查找一个模板 就以这个模板为例 2、在node1 上使用此模板 1、安装配置 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,126,489
精华内容 850,595
关键字:

模板