牛客面试必考算法题刷题

最新推荐文章于 2024-06-27 21:24:55 发布
最新推荐文章于 2024-06-27 21:24:55 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mimeidongyu/article/details/109838799
版权

文章目录

tips

注意重写比较函数，一般出现在堆和sort函数时，堆的重写是

struct cmp {
   
    bool operator() (const pair<string, int> &a, const pair<string, int> &b) {
   
        if(a.second == b.second) return a.first < b.first;
        return a.second > b.second;
    }
};

sort函数的重写为

static bool cmp(const Interval &int1, const Interval &int2) {
   
        return int1.start < int2.start;
    }

设计LRU缓存结构

设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能
set(key, value)：将记录(key, value)插入该结构
get(key)：返回key对应的value值
[要求]
set和get方法的时间复杂度为O(1)
某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。
若opt=1，接下来两个整数x, y，表示set(x, y)
若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1
对于每个操作2，输出一个答案

设置两个vector，分别按常用顺序存储key和value，set方法就是当vector大小小于k时，直接存储，如果大于k，则把容器头部的元素删除。get方法就是查找key，如果没找到返回-1，找到就把原有位置上的key删掉，然后插入新的key，就相当于get方法是在更新操作

class Solution {
   
public:
    /**
     * lru design
     * @param operators int整型vector<vector<>> the ops
     * @param k int整型 the k
     * @return int整型vector
     */
    vector<int> LRU(vector<vector<int> >& operators, int k) {
   
        // write code here
        vector<int> res;
        vector<int> keys;
        vector<int> values;
        if(operators.size() == 0) return{
   };
        for(int i=0; i<operators.size(); i++) {
   
            if(operators[i][0] == 1) {
   
                int key = operators[i][1];
                int value = operators[i][2];
                set(key, value, keys, values, k);
            }
            else if(operators[i][0] == 2) {
   
                int key = operators[i][1];
                res.push_back(get(keys, values, key));
            }
        }
        return res;
    }
    void set(int key, int value, vector<int>& keys, vector<int>& values, int k) {
   
        if(keys.size() < k) {
   
            keys.push_back(key);
            values.push_back(value);
        }
        else {
   
            keys.erase(keys.begin());
            values.erase(values.begin());
            keys.push_back(key);
            values.push_back(value);
        }
    }
    int get(vector<int>& keys, vector<int>& values, int key) {
   
        int pos = -1;
        for(int i=0; i<keys.size(); i++) {
   
            if(keys[i] == key) {
   
                pos = i;
                break;
            }
        }
        if(pos == -1) return -1;
        int temp = values[pos];
        keys.erase(keys.begin()+pos);
        values.erase(values.begin()+pos);
        keys.push_back(key);
        values.push_back(temp);    //此时values[pos]已经变了
        return temp;
    }
};

判断链表中是否有环

判断给定的链表中是否有环

class Solution {
   
public:
    bool hasCycle(ListNode *head) {
   
        if(head == nullptr) return false;
        ListNode *fast = head, *slow = head;
        while(fast && fast->next && slow) {
   
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast) return true;
        }
        return false;
    }
};

二分查找

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

要注意的是有重复数字，所以要找到mid时要判断一下左边的数是不是也等于mid，还有就是找不到时返回的是大于它的值，所以返回left

class Solution {
   
public:
    /**
     * 二分查找
     * @param n int整型 数组长度
     * @param v int整型 查找值
     * @param a int整型vector 有序数组
     * @return int整型
     */
    int upper_bound_(int n, int v, vector<int>& a) {
   
        if(a.size() == 0) return 1;
        // write code here
        int left = 0, right = n-1, mid;
        while(left <= right) {
   
            mid = (left + right)/2;
            if(a[mid] == v) {
   
                if(mid > 0 && a[mid - 1] == v) right = mid - 1;
                else return mid + 1;
            }
            else if(a[mid] > v) {
   
                right = mid - 1;
            }
            else {
   
                left = mid + 1;
            }
        }
        if(left > right) {
   
            return left + 1;
        }
    }
};

实现二叉树先序、中序、后序遍历

分别按照二叉树先序，中序和后序打印所有的节点。

class Solution {
   
public:
    /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > threeOrders(TreeNode* root) {
   
        // write code here
        vector<vector<int> > res;
        vector<int> v1, v2, v3;
        pre(root, v1);
        res.push_back(v1);
        mid(root, v2);
        res.push_back(v2);
        back(root, v3);
        res.push_back(v3);
        return res;
        
    }
    void pre(TreeNode* root, vector<int>& v) {
   
        if(root == nullptr) return;
        v.push_back(root->val);
        pre(root->left, v);
        pre(root->right, v);
    }
    void mid(TreeNode* root, vector<int>& v) {
   
        if(root == nullptr) return;
        mid(root->left, v);
        v.push_back(root->val);
        mid(root->right, v);
    }
    void back(TreeNode* root, vector<int>& v) {
   
        if(root == nullptr) return;
        back(root->left, v);
        back(root->right, v);
        v.push_back(root->val);
    }
};

寻找第K大

有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。

class Finder {
   
public:
    int findKth(vector<int> a, int n, int K) {
   
        // write code here
        if(a.size() == 0) return 0;
        if(a.size() == 1) return a[0];
        int index, left = 0, right = n - 1;
        index = Partition(a, left, right);
        while(K-1 != index) {
   
            if(index < K-1) {
   
                left = index + 1;
                index = Partition(a, left, right);
            }
            else {
   
                right = index - 1;
                index = Partition(a, left, right);
            }
        }
        return a[index];
    }
    int Partition(vector<int>&a, int i, int j) {
   
        int temp = a[i];
        while(i < j) {
   
            while(temp >= a[j] && i < j) j--;
            a[i] = a[j];
            while(temp <= a[i] && i < j) i++;
            a[j] = a[i];
        }
        a[j] = temp;
        return j;
    }
};

合并有序链表

将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。

这道题给的listnode结构里没有构造方法，因此不设置哨兵节点

class Solution {
   
public:
    /**
     * 
     * @param l1 ListNode类 
     * @param l2 ListNode类 
     * @return ListNode类
     */
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
   
        // write code here
        ListNode *newhead, *p;
        if(l1 == nullptr && l2 == nullptr) return nullptr;
        if(l1 == nullptr) return l2;
        if(l2 == nullptr) return l1;
        if(l1->val < l2->val) {
   newhead = l1; l1 = l1->next;}
        else {
   newhead = l2; l2 = l2->next;}
        p = newhead;
        while(l1 && l2) {
   
            if(l1->val < l2->val) {
   
                p->next = l1;
                p = p->next;
                l1 = l1->next;
            } else {
   
                p->next = l2;
                p = p->next;
                l2 = l2->next;
            }
        }
        if(l1) p->next = l1;
        if(l2) p->next = l2;
        return newhead;
    }
};

求二叉树的层次遍历

要按照一层一层返回

class Solution {
   
public:
    /**
     * 
     * @param root TreeNode类 
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > levelOrder(TreeNode* root) {
   
        // write code here
        if(root == nullptr) return {
   };
        vector<vector<int> > res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
   
            int size = que.size();
            vector<int> temp;
            while(size--) {
   
                TreeNode *p = que.front();
                temp.push_back(p->val);
                que.pop();
                if(p->left) que.push(p->left);
                if(p->right) que.push(p->right);
            }
            res.push_back(temp);
        }
        return res;
    }
};

括号序列

给出一个仅包含字符’(’,’)’,’{’,’}’,’[‘和’]’,的字符串，判断给出的字符串是否是合法的括号序列
括号必须以正确的顺序关闭，"()“和”()[]{}“都是合法的括号序列，但”(]“和”([)]"不合法。

用栈实现，左括号进栈，遇到右括号就出栈

class Solution {
   
public:
    /**
     * 
     * @param s string字符串 
     * @return bool布尔型
     */
    bool isValid(string s) {
   
        // write code here
        stack<char> stk;
        for(int i=0; i<s.length(); i++) {
   
            if(s[i] == '[' || s[i] == '(' || s[i] == '{') {
   
                stk.push(s[i]);
            } else if(s[i] == ']' || s[i] == ')' || s[i] == '}') {
   
                if(stk.empty()) return false;
                char c = stk.top();
                if(match(c, s[i])) stk.pop();
                else return false;
            }
        }
        if(!stk.empty()) return false;
        return true;
    }
    bool match(char c1, char c2) {
   
        if(c1 == '(' && c2 == ')') return true;
        if(c1 == '[' && c2 == ']') return true;
        if(c1 == '{' && c2 == '}') return true;
        return false;
    }
};

删除列表的倒数第n个节点

给定一个链表，删除链表的倒数第n个节点并返回链表的头指针

双指针

class Solution {
   
public:
    /**
     * 
     * @param head ListNode类 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* removeNthFromEnd(ListNode* head, int n) {
   
        // write code here
        if(head == nullptr || n == 0) return nullptr;
         ListNode *p = head, *r, *q = head;
         for(int i=0; i<n-1; i++) {
   
             if(q == nullptr) return nullptr; 	//n大于链表长度
             q = q->next;
         }
         if(q == nullptr) return nullptr;	//n大于链表长度
         while(q->next) {
   
             r = p;
             p = p->next;
             q = q->next;
         }
        if(p == head) return head->next;	//删除的节点是头结点
        r->next = p->next;
        return head;
    }
};

链表中的节点每k个一组翻转

将给出的链表中的节点每k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。
空间复杂度O(1)

class Solution {
   
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
   
        // write code here
        if(head == nullptr || k == 1) return head;
        int sum = 0;
        ListNode *p = head, *r = nullptr, *hhead, *temp, *tail, *temp1;	//hhead就是新链表的头，temp1是每一组的第一个节点，记录下来为了下一组翻转时挂在该节点后面
        tail = new ListNode(0);	//tail是每前一组翻转链表的尾部
        while(p) {
   
            p = p->next;
            sum++;
        }
        p = head;
        int flag = 0;
        while(sum) {
   
            if(sum >= k) {
   
                for(int i=0; i<k; i++) {
   
                    if(i == 0) temp1 = p;
                    temp = p->next;
                    tail->next = p;
                    p->next = r;
                    r = p;
                    p = temp;
                }
                if(flag == 0) {
   hhead = tail; flag = 1;}	//给头结点赋值
                tail = temp1;
                sum -= k;
            }
            else {
   
                tail->next = p;
                if(flag == 0) {
   hhead = tail; flag = 1;}
                break;
            }
        }
        return hhead->next;
    }
};

在二叉树中找到两个节点的最近公共祖先节点

给定一棵二叉树以及这棵树上的两个节点 o1 和 o2，请找到 o1 和 o2 的最近公共祖先节点。

用递归实现，判断两个节点是否在同一棵树上，如果在同一棵树上就继续递归寻找，如果不在同一棵树上就返回根节点，如果一个节点是另一个节点的父节点，就返回那个节点

class Solution {
   
public:
    /**
     * 
     * @param root TreeNode类 
     * @param o1 int整型 
     * @param o2 int整型 
     * @return int整型
     */
    int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
   
        // write code here
        if(root == nullptr) return 0;
        if(root->val == o1 || root->val == o2) return root->val;
        if(search(root->left, o1) && search(root->right, o2)) return root->val;
        if(search(root->right, o1) && search(root->left, o2)) return root->val;
        if(search(root->left, o1) && search(root->left, o2)) return lowestCommonAncestor(root->left, o1, o2);
        if(search(root->right, o1) && search(root->right, o2)) return lowestCommonAncestor(root->right, o1, o2);
    }
    bool search(TreeNode* root, int o) {
   
        if(root == nullptr) return false;
        if(root->val == o) return true;
        if(search(root->left, o)) return true;
        if(search(root->right, o)) return true;
        return false;
    }
};

合并两个有序的数组

给出两个有序的整数数组A和B，请将数组A合并到数组B中，变成一个有序的数组
注意：
可以假设A数组有足够的空间存放B数组的元素，A和B中初始的元素数目分别为m和n

class Solution {
   
public:
    void merge(int A[], int m, int B[], int n) {
   
        int p1 = m-1, p2 = n-1, p = m+n-1;
        while(p1 >=0 && p2 >= 0) {
   
            if(A[p1] > B[p2]) {
   
                A[p--] = A[p1--];
            } else {
   
                A[p--] = B[p2--];
            }
        }
        while(p1 >= 0) {
   
            A[p--] = A[p1--];
        }
        while(p2 >= 0) {
   
            A[p--] = B[p2--];
        }
        return;
    }
};

最长公共子串

给定两个字符串str1和str2,输出两个字符串的最长公共子串，如果最长公共子串为空，输出-1。

动态规划，但是这里用的是二维数组，后续可以改成一维数组

class Solution {
   
public:
    /**
     * longest common substring
     * @param str1 string字符串 the string
     * @param str2 string字符串 the string
     * @return string字符串
     */
    string LCS(string str1, string str2) {
   
        // write code here
        int len1 = str1.length(), len2 = str2.length(), maxlength = 5005, maxlen = 0, start;
        if(len1 == 0 || len2 == 0) return "-1";
        int dp[maxlength][maxlength];
        memset(dp, 0, sizeof(dp));
        for(int i=1; i<=len1; i++) {
   
            for(int j=1; j<=len2; j++) {
   
                if(str1[i-1] == str2[j-1]) {
       // 因为i j都是从1开始 所以要-1
                    dp[i][j] = dp[i-1][j-1] + 1;
                }
                if(dp[i][j] > maxlen) {
   
                    maxlen = dp[i][j];
                    start = i;
                }
            }
        }
        if(maxlen == 0) return "-1";
        return str1.substr(start-maxlen, maxlen);
    }
};

两数之和

给出一个整数数组，请在数组中找出两个加起来等于目标值的数，
你给出的函数twoSum 需要返回这两个数字的下标（index1，index2），需要满足 index1 小于index2.。注意：下标是从1开始的
假设给出的数组中只存在唯一解

用哈希表

class Solution {
   
public:
    /**
     * 
     * @param numbers int整型vector 
     * @param target int整型 
     * @return int整型vector
     */
    vector<int> twoSum(vector<int>& numbers, int target) {
   
        // write code here
        map<int, int> m;
        vector<int> res;
        for(int i=1; i<=numbers.size(); i++) {
   
            m[numbers[i-1]] = i;
        }
        for(int i=0; i<numbers.size(); i++) {
   
            int temp = target - numbers[i];
            if(m.count(temp) != 0 && (i+1) != m[temp]) {
   
                res.push_back(i+1);
                res.push_back(m[temp]);
                break;
            }
        }
        return res;
    }
};

子数组的最大累加和问题

给定一个数组arr，返回子数组的最大累加和

class Solution {
   
public:
    /**
     * max sum of the subarray
     * @param arr int整型vector the array
     * @return int整型
     */
    int maxsumofSubarray(vector<int>& arr) {
   
        // write code here
        int sum = 0;
        for(int i=0; i<arr.size(); i++) {
   
            if(sum < 0) {
   
                int temp = max(sum + arr[i], arr[i]);
                sum = temp;
            }
            else {
   
                sum += arr[i];
            }
        }
        return sum;
    }
};

找到字符串的最长无重复子串

示例：
输入[2, 3, 4, 5] 输出4
输入[2, 2, 3, 4, 3] 输出3

用双指针和哈希表，双指针记录的是无重复子串的起始和结束位置，哈希表记录是否已经存在这个元素，如果发现起始和结束位置重复了，就更新起始位置

class Solution {
   
public:
    /**
     * 
     * @param arr int整型vector the array
     * @return int整型
     */
    int maxLength(vector<int>& arr) {
   
        // write code here
        if(arr.size() == 0) return 0;
        vector<int> v(100005);
        int i = 0, j = 0, res = 0;
        while(j < arr.size()) {
   
            if(v[arr[j]] == 0) {
   
                v[arr[j]] = 1;
                res = max(res, j-i+1);
                j++;
            } else {
   
                v[arr[i]] = 0;    //一定是j与i这两个位置上的元素重复了，因此把这个位置重置为0， 并且更新起始位置
                i++;
            }
        }
        return res;
    }
};

🌸最长递增子序列

给定数组arr，设长度为n，输出arr的最长递增子序列。（如果有多个答案，请输出其中字典序最小的）

解题思路
用动态规划是O(n^2)的时间复杂度，会运行超时，所以用贪心法加二分查找

class Solution {
   
public:
    /**
     * retrun the longest increasing subsequence
     * @param arr int整型vector the array
     * @return int整型vector
     */
    vector<int> LIS(vector<int>& arr) {
   
        // write code here
        vector<int> dp(arr.size(), 0);
        vector<int> end;
        dp[0] = 1;
        end.push_back(arr[0]);
        for(int i=1; i<arr.size(); i++) {
   
            if(arr[i] > end.back()) {
   
                end.push_back(arr[i]);
                dp[i] = end.size();
            }
            else {
   
                int index = search(0, end.size()-1, end, arr[i]);
                end[index] = arr[i];
                dp[i] = index + 1;
            }
        }
        vector<int> res(end.size(), INT_MAX);
        int len = end.size();
        for(int i=arr.size()-1; i>=0; i--) {
   
            if(dp[i] == len) {
   
                if(arr[i] < res[len-1]) {
   
                    res[len-1] = arr[i];
                }
                len--;
            }
        }
        return res;
    }
    
    int search(int left, int right, vector<int>& vec, int target) {
   
        while(left < right) {
   
            int mid = (left + right) / 2;
            if(vec[mid] < target) left = mid + 1;
            else right = mid; 
        }
        return left;
    }
};

反转字符串

写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000

用双指针，从前从后遍历字符串然后交换

class Solution {
   
public:
    /**
     * 反转字符串
     * @param str string字符串 
     * @return string字符串
     */
    string solve(string str) {
   
        // write code here
        int i = 0, j = str.length() - 1;
        while(i < j) {
   
            char temp = str[i];
            str[i] = str[j];
            str[j] = temp;
            i++;
            j--;
        }
        return str;
    }
};

螺旋矩阵

给定一个m x n大小的矩阵（m行，n列），按螺旋的顺序返回矩阵中的所有元素。

class Solution {
   
public:
    vector<int> spiralOrder(vector<vector<int> > &matrix) {
   
        if(matrix.size() == 0) return {
   };
        int rows = matrix.size(), cols = matrix[0].size();
        int left = 0, right = cols - 1, up = 0, down = rows - 1;
        vector<int> res;
        while(left <= right && up <= down) {
   
            for(int j=left; j<=right; j++) {
   
                res.push_back(matrix[up][j]);
            }
            up++;
            if(up > down) break;
            for(int i=up; i<=down; i++) {
   
                res.push_back(matrix[i][right]);
            }
            right--;
            if(left > right) break;
            for(int j=right; j>=left; j--) {
   
                res.push_back(matrix[down][j]);
            }
            down--;
            if(up > down) break;
            for(int i=down; i>=up; i--) {
   
                res.push_back(matrix[i][left]);
            }
            left++;
            if(left > right) break;
        }
        return res;
    }
};

两个链表生成相加链表

假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。
给定两个这种链表，请生成代表两个整数相加值的结果链表。

将两个链表先进行反转，从末位开始相加，并且计算进位。注意，反转链表的时候不需要用头插法，这道题如果用头插法会内存不够，所以要free

class Solution {
   
public:
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    ListNode* Reverse(
最低0.47元/天 解锁文章
请叫我迷妹
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客网面试必刷算法题TOP101刷题记录（一）
Miaodawang的博客
01-21 3693
思路 JZ6 从尾到头打印链表（简单） 题目描述： 思路1（非递归，通过） 从头到尾遍历，边遍历边存进栈，最后从栈弹出来打印。时间复杂度O(n)，空间复杂度O(n) public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { ArrayList<Integer> list = new ArrayList(); Stack stack = new St..
算法题刷题笔记
张紫娃的博客
02-02 793
正则 学习总结int[] &Integer[] &List
双指针算法题系列：最长连续递增序列，两种常用双指针写法
最新发布
qq_64892278的博客
06-27 723
双指针系列第三题，最后一道简单题。
手把手带你刷好题（牛客刷题①）
yanxiang3306
08-24 2386
牛客-找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决
python 面试题 牛客_python之牛客网刷题总结
weixin_32329555的博客
03-01 442
1.max = x > y ? x : y 不是python的语法，这一点特别容易混淆；python三元运算符的使用如下：a if x>y else b2.random.random()生成0和1之间的随机浮点数float3.假设可以不考虑计算机运行资源(如内存)的限制，以下 python3 代码的预期运行结果是：()import mathdef sieve(size):sieve= ...
牛客刷题处理输入
qq_42772967的博客
04-12 269
在牛客刷题有时候需要自己处理输入输出，输出相对就比较简单，但输入有时相对较难处理，以上代码是一个典型的输入处理。如下图是运行结果，2是接下来输入两行，接着输入两行字符串，最后转变成整数存储在vector中。
【牛客网——算法刷题】开篇介绍
赵四司机的博客
08-25 5703
主要介绍如何利用牛客网来进行刷题学习
刷题笔记（牛客java选择题）
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
11-01 451
这些常见的面试选择题，你会了吗？
算法刷题网站推荐
weixin_41171614的博客
03-22 1569
算法刷题网站推荐
【牛客刷题】java编程笔试题（更新）
世界很大我很小
08-28 3308
思路：用hashmap保存每个字符串的出现次数，每次输入一个字符串，判断该字符串是否在hashmap中，没有就插入value为1key为该字符串的值，存在则更新value+1。这里的有效序列定义为S中的每个字符在L中都存在，并且顺序一致，例如“ace”是“abcde”的有效序列，“aec”不是“abcde”的有效序列，但是ae是最长的有效序列，e是最后一个有效字符。如果匹配失败一次，则母串下标+1，继续匹配，当子串或母串下标超出长度则停止，输入记录的最后有序字符下标。............
【牛客】华为笔试算法题练习（简单篇）JavaScript V8 实现
倏存的博客
09-02 1020
牛客网华为面试题链接 本文都是自己写的从牛客上直接截图下来的，因为牛客的输入输出与常规写的优点不同，这点可以自己百度。 我自己摸索出来的，在Java Script V8 模式下，点开ACM模式，里面有说明，可以把代码复制下来，然后其中的line就表示你要用到的变量。本文只有牛客上归类为简单的算法题。 简单篇1. 输出逆序的字符串2.求最小公倍数3. 四舍五入4.字符串反转5. 颠倒整数6. 统计每个月兔子的总数7.未完待续。。。。 1. 输出逆序的字符串 牛客网-点击链接进入该题目 -描述：将一个字符.
牛客面试算法top101（JAVA和C++）
04-30
牛客面试算法top101（JAVA和C++）是指牛客网提供的面试算法题库中的top101道题，涵盖了JAVA和C++两种编程语言。这些题目涵盖了算法刷题的基本知识和技巧，是面试算法的基础知识。 描述解读 牛客面试算法top101...
python 数据结构 算法 LeetCode 牛客 面试
06-17
LeetCode和牛客等平台提供了大量面试相关的算法题目，涵盖排序、搜索、图论、动态规划等多个方面。 1. 排序算法：Python内置的`sorted()`函数和列表的`sort()`方法可以方便地进行排序。此外，还可以手动实现冒泡...
202届秋招Java架构面试总结。包含：算法刷题、Java基础，集合、JVM
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
JAVA面试题及答案参考，JAVA面试前刷刷题
08-06
JAVA面试题及答案参考，JAVA面试前刷刷题 JAVA面试题及答案参考是帮助Java开发者准备面试的重要资源。通过刷题，可以熟悉语言的基本概念和应用场景，提高自己的编程能力和分析问题的能力。在面试之前，刷题可以帮助...
牛客校招面试题（附答案与解析）c++
07-31
"牛客校招面试题（附答案与解析）c++"是一个针对C++编程语言的面试题集合，旨在帮助应聘者准备企业校园招聘中的技术面试。这个压缩包文件很可能包含了一系列的C++题目，涵盖了基础知识、数据结构、算法、STL...
算法设计-动态规划(2)-背包问题
mimeidongyu的博客
11-20 577
动态规划 背包问题 0-1背包问题 有一个容量为V的背包，有n种物品，每种物品都有自己的重量w和价值v，每种物品都只有一个，现给出让该背包装最大价值的物品的方案。 子问题是，对于每个物品，装下或者装不下。如果装不下，那么和前i-1个物品的最大价值是一样的。如果能够装下，但是装了之后不一定会大于当前相同体积的最优价值。 状态是d[i][j]，表示的是当背包容量为j时，前i个物品所能达到的最大价值。 ...
算法设计-动态规划(1)-子序列和最大问题
mimeidongyu的博客
11-18 503
算法设计-动态规划 子序列和最大问题 子序列和最大 递推方程：d[i] = max{a[i], d[i-1]+a[i]}，d[i]表示的是子序列一定会包含第i个元素的最大和，要么是从a[i]开始，要么是在原来的最大序列上再添一个a[i]。最终得到的最大子序列和是max{d[i]}(0<=i<=n) 代码如下： //b[i]的状态转移方程：b[i]=max{b[i-1]+a[i],a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值