【算法笔记】入门篇一

最新推荐文章于 2024-07-25 16:35:35 发布
最新推荐文章于 2024-07-25 16:35:35 发布
阅读量318 收藏 7
点赞数 8
分类专栏： 数据结构与算法 文章标签： 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50952205/article/details/135855723
版权

文章目录

PAT1042

#include <iostream>
#include <string>

using namespace std;
int main() {
    int K;
    int start[55], end[55], next[55];
    cin >> K;

    for (int i = 1; i <= 54; i++) { // 第i个元素总是放到第next[i]个元素上
        cin >> next[i];
    }

    for (int i = 1; i <= 54; i++) {
        start[i] = i;
    }

    for (int j = 0; j < K; j++) {
        for (int i = 1; i <= 54; i++) {
            end[next[i]] = start[i];   
        }

        for (int i = 1; i <= 54; i++) {
            start[i] = end[i];
        }
    }

    string s[55] = {" ", "S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8", "S9", "S10", "S11", "S12", "S13",
                     "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9", "H10", "H11", "H12", "H13",
                     "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10", "C11", "C12", "C13",
                     "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "D10", "D11", "D12", "D13",
                     "J1", "J2"};

    for (int i = 1; i <= 54; i++) {
        cout << s[start[i]];
        if (i != 54) cout << " ";
    }
}

PAT1046

这题很简单，求两点间最短路径，时间限制是O（n），一开始写了一个平方复杂度的代码，最后一个超时了，用数组存起从v1到某点距离，这样就不用每次都计算了√。

#include <iostream>
#include <cmath>

using namespace std;
int main() {
    int N, M, sum = 0;
    cin >> N;
    int d[N+1], D[N+1]; 

    for (int i = 1; i <= N; i++) {
        cin >> d[i];
    }

    D[1] = 0;
    for (int i = 2; i <= N; i++) {
        D[i] = D[i-1] + d[i-1];
    }
    sum = D[N] + d[N];

    cin >> M;
    int v1, v2, temp;
    for (int i = 0; i < M; i++) {
        cin >> v1 >> v2;
        temp = abs(D[v1] - D[v2]);
        temp = temp < (sum - temp) ? temp : (sum - temp);
        cout << temp << endl;
    }
}

PAT1009

多项式，注意最后系数为零不用输出，总是有这种。。不难但是要考虑一些比较特殊的测试用例。

#include <algorithm>

using namespace std;
struct node {
    int exp;
    float c;
};

bool cmp(node n1, node n2) {
    return n1.exp > n2.exp;
}

int main() {
    int K1, K2;
    vector<node> p1, p2, p3;

    cin >> K1;
    for (int i = 0; i < K1; i++) {
        node p;
        cin >> p.exp >> p.c;
        p1.push_back(p);
    }

    cin >> K2;
    for (int i = 0; i < K2; i++) {
        node p;
        cin >> p.exp >> p.c;
        p2.push_back(p);
    }

    for (int i = 0; i < K1; i++) {
        for (int j = 0; j < K2; j++) {
            node p;
            p.exp = p1[i].exp + p2[j].exp;;
            p.c = p1[i].c * p2[j].c;
            p3.push_back(p);
        }
    }
    
    sort(p3.begin(), p3.end(), cmp);
    int e = p3[0].exp;
    int idx = 0, k = 1;
    while (k < p3.size()) {
        if (e == p3[k].exp) {
            p3[idx].c += p3[k].c;
            p3.erase(p3.begin() + k);
        } else {
            e = p3[k].exp;
            idx = k;
            k ++;
        }
    }

    k = 0;
    while (k < p3.size()) {
        if (p3[k].c == 0.0) {
            p3.erase(p3.begin() + k);
        } else {
            k ++;
        }
    }

    cout << p3.size();
    for (int k = 0; k < p3.size(); k++) {
        printf(" %d %.1f", p3[k].exp, p3[k].c);
    }
}

PAT1011

真·送分题

#include <iostream>
#include <algorithm>


using namespace std;
int main() {
    float a, b, c, m, result = 1.0;
    for (int i = 0; i < 3; i++) {
        cin >> a >> b >> c;
        m = max(max(a,b), c);
        result *= m;
        if (a == m) cout << "W";
        else if (b == m) cout << "T";
        else cout << "L";
        cout << " ";
    }

    result = (result * 0.65 - 1) * 2;
    printf("%.2f", result);
}

PAT1006

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;
struct stu {
    string id;
    string in;
    string out;
};

bool cmp1(stu s1, stu s2) {
    string str1 = s1.in, str2 = s2.in;
    int hour1, hour2;
    int min1, min2;
    int sec1, sec2;
    hour1 = stoi(str1.substr(0, 2));
    hour2 = stoi(str2.substr(0, 2));
    min1 = stoi(str1.substr(3, 2));
    min2 = stoi(str2.substr(3, 2));
    sec1 = stoi(str1.substr(6, 2));
    sec2 = stoi(str2.substr(6, 2));

    if (hour1 < hour2) return true;
    else if (hour1 == hour2 && min1 < min2) return true;
    else if (hour1 == hour2 && min1 == min2 && sec1 < sec2) return true;
    else return false;
}

bool cmp2(stu s1, stu s2) {
    string str1 = s1.out, str2 = s2.out;
    int hour1, hour2;
    int min1, min2;
    int sec1, sec2;
    hour1 = stoi(str1.substr(0, 2));
    hour2 = stoi(str2.substr(0, 2));
    min1 = stoi(str1.substr(3, 2));
    min2 = stoi(str2.substr(3, 2));
    sec1 = stoi(str1.substr(6, 2));
    sec2 = stoi(str2.substr(6, 2));

    if (hour1 < hour2) return true;
    else if (hour1 == hour2 && min1 < min2) return true;
    else if (hour1 == hour2 && min1 == min2 && sec1 < sec2) return true;
    else return false;
}

int main() {
    int M;
    vector<stu> s;
    cin >> M;

    for (int i = 0; i < M; i++) {
        stu student;
        cin >> student.id >> student.in >> student.out;
        s.push_back(student);
    }

    sort(s.begin(), s.end(), cmp1);
    cout << s[0].id << " ";

    sort(s.begin(), s.end(), cmp2);
    cout << s[s.size() - 1].id;
}

PAT1036

#include <iostream>
#include <cmath>

using namespace std;

struct stu{
    string name;
    string id;
};

int main() {
    int s_M = 101, s_F = -1;
    stu man, female;
    int N;
    cin >> N;

    string name, sex, id;
    int score;
    for (int i = 0; i < N; i++) {
        cin >> name >> sex >> id >> score;
        if (sex == "M" && score < s_M) {
            man.name = name;
            man.id = id;
            s_M = score;
        } else if (sex == "F" && s_F < score) {
            female.name = name;
            female.id = id;
            s_F = score;
        }
    }

    if (s_F != -1) cout << female.name << " " << female.id << endl;
    else cout << "Absent" << endl;
    if (s_M != 101) cout << man.name << " " << man.id << endl;
    else cout << "Absent" << endl;

    if (s_F != -1 && s_M != 101) cout << abs(s_F - s_M);
    else cout << "NA";
}

PAT1031

#include <iostream>
#include <string>

using namespace std;
int main() {
    string str;
    int len, n1, n2, n3;
    cin >> str;

    len = str.length();
    n1 = (len + 2) / 3;
    n3 = n1;
    n2 = len - n1 * 2 + 2;

    for (int i = 0; i < n1 - 1; i++) {
        cout << str[i];
        for (int j = 0; j < n2 - 2; j++) {
            cout << " ";
        }
        cout << str[len - 1 - i] << endl;
    }

    for (int i = 0; i < n2; i++) {
        cout << str[n1 - 1 + i];
    }
}

PAT1019

进制转换：

#include <iostream>
#include <vector>

using namespace std;
int main() {
    int N, b;
    int mob, num;
    vector<int> ans;

    cin >> N >> b;
    num = N;
    while (num != 0) {
        mob = num % b;
        num = num / b;
        ans.push_back(mob);
    }

    int flag = 1;
    for (int i = 0, j = ans.size()-1; i <= j; i++, j--) {
        if (ans[i] != ans[j]) {
            flag = 0;
            break;
        }
    }

    if (flag) cout << "Yes" << endl;
    else cout << "No" << endl;

    for (int i = ans.size() - 1; i >= 0; i--) {
        cout << ans[i];
        if (i != 0) cout << " ";
    }
}

PAT1058

#include <iostream>
#include <string>

using namespace std;
int main() {
    int a[3], b[3], c[3];
    int carry;
    scanf("%d.%d.%d %d.%d.%d", &a[0], &a[1], &a[2], &b[0], &b[1], &b[2]);

    c[2] = (a[2] + b[2]) % 29; // 当前位
    carry = (a[2] + b[2]) / 29; // 进位
    c[1] = (a[1] + b[1] + carry) % 17;
    carry = (a[1] + b[1] + carry) / 17;
    c[0] = a[0] + b[0] + carry;

    cout << c[0] << '.' << c[1] << '.' << c[2];
}

PAT1061

主要考的字符匹配。ascll码的转换，感觉printf与scanf更灵活，可以按格式输入输出。
排除错误：

  1. 根据自己理解的逻辑检查代码。
  2. 仔细阅读题目，考虑边缘测试用例。
#include <iostream>
#include <string>

using namespace std;
int main() {
    string str1, str2, str3, str4;
    string day[7] = {"MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"};
    
    cin >> str1 >> str2 >> str3 >> str4;

    int flag = 0;
    for (int i = 0; i < str1.length() && i < str2.length(); i++) {
        if (str1[i] == str2[i] && !flag && str1[i] >= 'A' && str1[i] <= 'G') { // 保证不超出边界
            cout << day[str1[i] - 'A'] << " ";
            flag = 1;
            continue;
        }
        if (str1[i] == str2[i] && flag) {
            if (str1[i] >= '0' && str1[i] <= '9') {
                printf("%02d", str1[i] - '0'); 
                break;
            }
            if (str1[i] >= 'A' && str1[i] <= 'N') {
                printf("%02d", str1[i] - 'A' + 10);
                break;
            }
        }
    }
    
    for (int i = 0; i < str3.length() && i < str4.length(); i++) {
        if (str3[i] == str4[i]) {
            if ((str3[i] >= 'A' && str3[i] <= 'Z') || (str3[i] >= 'a' && str3[i] <= 'z')) {
                printf(":%02d", i);
                break;
            }
        }
    }
}

PAT1073

这题主要复杂在有效位位数要保持一致，所以只能以字符串的形式处理输出，不能以数字的形式处理输出。

#include <iostream>
#include <string>
#include <cmath>

using namespace std;
int main() {
    int exp, idx;
    int count = 0; // 记录有效位位数
    string num, ans, s, note1, note2;

    cin >> s;

    note1 = s[0];
    idx = s.find('E') + 1;
    note2 = s[idx];
    
    num = s.substr(1, idx - 2);
    num.erase(num.find('.'), 1);
    exp = stoi(s.substr(idx + 1, s.length() - idx - 1));
    count = s.find('E') - s.find('.') - 1 - exp;

    if (note1 == "-") cout << '-';

    if (note2 == "-") {
        cout << "0.";
        for (int i = 0; i < exp - 1; i++) {
            cout << "0";
        }
        cout << num;
    }

    if (note2 == "+") {
        if (count > 0) {
            num.insert(num.length() - count, ".");
            cout << num;
        } else {
            cout << num;
            for (int i = 0; i < abs(count); i++) {
                cout << "0";
            }
        }
    }                  
}

PAT1005

#include <iostream>
#include <string>

using namespace std;
int main() {
    string num[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    string N, str_sum;
    int sum = 0;
    cin >> N;

    for (int i = 0; i < N.length(); i++) {
        sum += N[i] - '0';
    }

    str_sum = to_string(sum);
    int temp;
    for (int i = 0; i < str_sum.length(); i++) {
        temp = str_sum[i] - '0';
        cout << num[temp];
        if (i != str_sum.length() - 1) cout << " ";
    }
}

PAT1035

#include <iostream>
#include <string>
#include <vector>

using namespace std;
struct user {
    string id;
    string password;
};
int main () {
    int N;
    vector<user> v;
    string id, password;

    cin >> N;
    int flag;
    for (int i = 0; i < N; i++) {
        cin >> id >> password;
        flag = 0;
        for (int j = 0; j < password.length(); j++) {
            if (password[j] == '1') {
                password[j] = '@';
                flag = 1;
            }
            else if (password[j] == '0') {
                password[j] = '%';
                flag = 1;
            }
            else if (password[j] == 'l') {
                password[j] = 'L';
                flag = 1;
            }
            else if (password[j] == 'O') {
                password[j] = 'o';
                flag = 1;
            }
        }

        user u;
        u.id = id;
        u.password = password;

        if (flag == 1) v.push_back(u);
    }

    if (v.size() == 0) {
        if (N == 1) printf("There is 1 account and no account is modified");
        else printf("There are %d accounts and no account is modified", N);
    }
    else {

PAT1077

寻找公共后缀，注意大小对齐。这题debug好久，，测试点3一直不过，后来发现，原来是因为字符串设置太小了，0-256，应设置字符数组大小257.

int main() {
    int N, end, start;
    char s1[257], s2[257];
    cin >> N;

    getchar(); // 读入换行符
    cin.getline(s1, 257);
    start = 0;
    for (int i = 1; i < N; i++) {
        cin.getline(s2, 257);
        end = strlen(s1);
        if (strlen(s2) < end - start) start = end - strlen(s2);
        for (int j = strlen(s2) - 1; j >= 0 && end > start; j--, end--) {
            if (s1[end-1] != s2[j]) {
                start = end;
                break;
            }
        }
    }

    if (start >= strlen(s1)) cout << "nai";
    else {
        for (int i = start; i < strlen(s1); i++) {
            printf("%c", s1[i]);
        }
    }
}

把求公共后缀转化为求公共前缀版本：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
int main() {
    int N, end, len1, len2;
    char s1[257], s2[257];
    cin >> N;

    getchar(); // 读入换行符
    cin.getline(s1, 257);
    len1 = strlen(s1);
    end = len1; // 左闭右开
    reverse(s1, s1 + len1);
    for (int i = 1; i < N; i++) {
        cin.getline(s2, 257);
        len2 = strlen(s2);
        reverse(s2, s2 + len2);
        if (len2 < end) end = len2;
        for (int j = 0, k = 0; j < len2 && k < end; j++, k++) {
            if (s1[k] != s2[j]) {
                end = k;
                break;
            }
        }
    }

    if (end == 0) cout << "nai";
    else {
        for (int i = end - 1; i >= 0; i--) {
            printf("%c", s1[i]);
        }
    }
}

PAT1082

#include <iostream>
#include <string>
#include <vector>

using namespace std;
int main() {
    string num[10] = {"ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};
    string l1[4] = {"00", "11", "Wan", "Yi"};
    string l2[5] = {"22", "33", "Shi", "Bai", "Qian"};   
    int start = 0, end, len, r; 
    string s;
    vector<string> ans;

    cin >> s;
                     
    if (s[0] == '-') { // 为负数的情况
        cout << "Fu" << " ";
        s.erase(0, 1);
    }

    if (s.length() == 1 && s == "0") cout << num[0]; // 为0的情况

    len = s.length();
    r = len / 4 + 1;
    end = len - (r - 1) * 4;
    int flag; // 多个零只读一个
    int flag2; // 排除万位级全为零的情况
    for (int i = 0; i < r; i++) {
        flag = 0;
        flag2 = 0;
        for (int j = start; j < end; j++) {
            if (s[j] != '0') flag2 = 1; // 当前级读到一个不为0的数位
            if (s[j] == '0') { // 读到0，标记
                flag = 1;
                continue;
            }
            if (flag == 1 && s[j] != '0') {
                ans.push_back("ling");
                flag = 0;
            }
            ans.push_back(num[s[j] - '0']);
            if (j != end - 1) ans.push_back(l2[end - j]);
        }
        if (r - i > 1 && flag2) ans.push_back(l1[r - i]);
        start += end - start;
        end += 4;
    }
    
    for (int i = 0; i < ans.size(); i++) {
        cout << ans[i];
        if (i != ans.size() - 1) cout << " ";
    }          
}
海心巧克力
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【算法笔记】分而治之
CambridgeChao的博客
03-30 228
分而治之 求逆序数 void Merge(string a,int low,int mid,int high){//参考合并两个链表的时候的做法 int tmpa[high-low+1]; int ans=0; int i=low,j=mid+1,k=0;//i,j分别是指向两个数列对应的位置的，k是指向最终的数列中位置的坐标 while(i<=mid&&j<=high){ if(a[i]<=a[j]){ tmpa[k++]=a[i++]; } e
《算法笔记》-读书笔记
m0_46304776的博客
03-16 125
第二章读书笔记 变量类型：int 从-2的31次方到2的31次方-1.，长整型后要加LL/ll。 c语言中使用布尔类型必须加头文件，stdbool.h才能使用，c++中可以直接使用 scanf读入字符数组时不用加& printf，%0md，输出时占m个字符，不足位置用0代替 常用的math函数： fabs（double x），取绝对值 floor（double x） ceil（double x），向上取整和向下取整 pow（double r，double p），返回r的p次方 sqrt（double
算法笔记入门篇-多项式求和
weixin_51264556的博客
10-01 3496
算法笔记入门篇-多项式求和 前言 1、题目描述 2、解题思路 3、代码实现 1、题目描述 给出两个多项式的系数，求出这两个多项式的乘积。 例如，第一个多项式为f(x)=2.4x+3.2，第二个多项式为g(x)=1.5x²+0.5x。那么最终乘积为： S(x)=3.6x³+6x²+1.6x。 对应的输入样例： 2（多项式项数） 1 2.4 0 3.2 2（多项式项数）2 1.5 1 0.5 输出样例： 3（多项式项数） 3 3.6 2 6.0 1 1.6 2、解题思路 我的个人思路是： a、定义三个数组，其
算法笔记--算法入门篇
WyjNabobess的博客
08-23 161
算法笔记中代码
数据结构与算法之美笔记入门篇
页页的博客
10-17 144
数据结构与算法入门篇
算法竞赛入门基础篇（个人整理）
05-07
个人整理的算法竞赛入门笔记。 包含常见函数及算法、基础算法、数据结构、搜索与图论、数学知识、动态规划、贪心和STL。许多小技巧在实际编程中很有用，合计106页。
计算机视觉与机器学习的入门级笔记
01-20
这篇入门级笔记旨在为初学者提供一个基础的框架，帮助理解这两个领域的核心概念和技术。 （一）引言 计算机视觉的主要任务包括图像分析、图像理解以及图像生成等，其核心目标是使机器能够“看”并理解世界。而机器...
java 学习笔记(入门篇)_程序流程控制结构和方法
09-05
1. **顺序结构**：这是最基本的结构，程序中的语句会按照它们在代码中出现的顺序依次执行。每条语句执行完毕后，才会执行下一条。例如，声明变量、初始化值、调用函数等操作都遵循顺序结构。 2. **选择结构**：选择...
深度学习入门基础笔记自己手写
04-29
这篇笔记将介绍深度学习的基础概念，包括感知器、线性单元、梯度下降以及多神经网络和反向传播。 **一、感知器** 感知器是深度学习中最基础的模型，它可以解决简单的二分类问题。例如，通过调整权重（W）和偏置（b...
PS入门笔记
09-25
这篇“PS入门笔记”主要介绍了PS的基本工具和视图菜单，帮助初学者掌握基础操作。 首先，窗口菜单允许用户管理和查看多个图像。通过F7键可以调出图层条板，方便切换和比较不同图片。全屏模式下，使用F键可以在带有...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 965
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 258
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
代码随想录算法训练营第二十二天|回溯算法part01
qq_43456971的博客
07-25 630
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 307
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1093
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1119
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
力扣题解（最大数）
yyssas的博客
07-24 368
因此按照上述做法得出的序列是x1,x2,x3.....,最优解是y1,y2,y3.....,假设前i-1个一样，则xi！=yi，假设xi==yj，则必有yiyj<yjyi，且对于处于i到j之间的数字组合z，yizyj<yjzyi，因此换i，j位置会大于等于未换位置的最优解，但是最优解是最大值，因此换后仍是最大值。正确性：若ab>ba,则acb>bca，保证了将任何数放ab之间，不改变大小关系。排序规则：对于数组中的数a和数b，若ab>ba，则a在前，b在后。对数组重新排列，使得按照题目所要求的顺序输出。
【常微分方程】
qq_74285286的博客
07-24 397
常微分方程笔记
小红书（社招二面）算法原题
最新发布
宫水三叶的刷题日记
07-25 938
但如果从百度（甚至是社会交通运输行业）的角度出发，萝卜快跑还是一个尚未全国铺开的产品，甚至还是一个内测产品，同时也代表了一个未来很有前景的行业，现如今却落入"抢人类饭碗"的社会问题舆论中，很容易就会导致整个行业被扼杀。从现在的环境分析，萝卜快跑的流量已经上来了，此时选择涨价到正常水平，可以进一步平衡订单的供求关系，又可以让舆论冷却，还能达成当时补贴是「为了拿到更多真实数据」的目的，是最符合经济原则的做法。首先，萝卜快跑的定价权是在百度手上的，萝卜快跑如今选择涨价，和网约车保持相当的水准。
算法资源笔记：从入门到进阶
这篇算法笔记主要分为两个大的部分：Useful Knowledge 和 Problem Solutions。在Useful Knowledge部分，作者列举了一些在算法设计和实现中经常遇到的基础知识和技巧： 1. Empirical Formulas（经验公式）：这部分...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值