SMU-ACM Spring 2024 2nd

最新推荐文章于 2024-11-16 10:02:08 发布
最新推荐文章于 2024-11-16 10:02:08 发布
阅读量348 收藏 7
点赞数 6
文章标签： 图论 算法 c++ 排序算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FS_tar/article/details/138086414
版权

文章目录

The Second Week

一、前言

日拱一卒无有尽，功不唐捐终入海。 ————《法华经·观世音菩萨普门品》
周日川大线上校赛，三人组队十二个小时。玛卡巴卡打得还不错吧感觉。
哎哟周二的cf个人赛，C题做崩了之后整个心态没了，做了俩三个小时，看着D题写不进去，交了16次也是给我整笑了。后来发现错的真的很无语。
周六晚上做了一下上届川大决赛题，哎哟签到题心态做崩了。

二、算法

1.二叉树

typedef struct treeNode
{
    int id;
    struct treeNode* LChild;
    struct treeNode* RChild;
}TREE,*LPTREE;
//结构体建树节点，LP一般代表指针别名

LPTREE createNode(int id,LPTREE l,LPTREE r) {
    LPTREE newNode = (LPTREE)malloc(sizeof(TREE));
    //malloc函数的作用是申请内存空间并返回给指针变量
    newNode->id = id;
    newNode->LChild = l;
    newNode->RChild = r;
    return newNode;
}
//建立一个节点

void insertNode(LPTREE parentNode,LPTREE LChild,LPTREE RChild) {
    parentNode -> LChild = LChild;
    parentNode -> RChild = RChild;
}
//在空节点下插入左右子节点

void printCurNodeData(LPTREE curDate) {
    std::cout << curData->data << endl;
}
//终于打印节点了

void preOrder(LPTREE root) {
    if(root != NULL) {
        printCurNodeData(root);
        preOrder(root->LChild);
        preOrder(root->RChild);
    }
}
//前序遍历：根左右（递归方式）



void midOrder(LPTREE root) {
    if(root != NULL) {
        midOrder(root->LChild);
        printCurNodeData(root);
        midOrder(root->RChild);
    }
}
//中序遍历：左根右（递归方式）

void lastOrder(LPTREE root) {
    if(root != NULL) {
        preOrder(root->LChild);
        preOrder(root->RChild);
        printCurNodeData(root);
    }
}
//后序遍历：左右根（递归方式）

2.贪心

贪心算法就是通过局部最优解达到整体最优解，经典的是选择排序。

<1>（CF set1746 B）

vjudge上的贪心题单，看了别人的代码写的。
题解：
给出t组案例，每组数组a包含n个数字0或1，要求求出最少经过几次运算，可以使得数组a是一个递增数组，每次运算即把ai加到aj上，去除ai。
从左右俩边往中间遍历，注意不要超出边界，每次有不符合递增条件的数字，都进行一次运算，然后继续遍历，直到l>=r。
数组的最小数字是0，但最大数字未必是1。
代码：

#include<iostream>
#include<utility>

using namespace std;

int main () {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    long long t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        int a[n];
        int ans = 0;
        for(int i = 0; i < n; i++) {
            cin >> a[i];
        }
        int l = 0, r = n-1;
        while(l < r) {
            while(a[l] == 0 && l < n)l++;
            while(a[r] != 0 && r > -1)r--;
            if(l >= r)break;
            ans++;
            l++;
            r--;
        }
        cout << ans << endl;
    }
    return 0;
}

3.快速幂

const long long mod = 1e9 + 10;
long long quick_pow ( long long base, long long b ) {
    long long ans = 1;
    while(b) {
        if( b & 1 != 0) {
            ans = ans * base % mod;
        }
        base = base * base % mod;
        b >>= 1;
    }
    return ans;
}

<1>（四川大学线上校赛 E）

做了三个小时，但现在网站不知道怎么个事，打不开了，找出了代码但是原题好像暂时看不了了。
题解：
打表可以看出1对应的是3的一次方，111对应的是3的三次方，以及给出的一组数据可以论证。而1000会比111多2，以此类推每一位的1可以代表增加的数字多少，数据过大所以得开快速幂。
代码：

#include<iostream>

const int MOD = 1e9 + 7;

using namespace std;

long long quick_pow(long long b) {
    long long res = 1;
    long long base = 3;
    while(b>0) {
        if(b & 1) res *= base;
        res %= MOD;
        base *= base;
        base %= MOD;
        b >>= 1;
    }
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    string l;
    cin >> l;
    long long ans = 1;
    long long t = 1;
    for(int i = 0; i < l.length(); i++) {
        if(l[i] == '1') {
            long long res = quick_pow(l.length()-1-i);
            res += 2;
            ans += (t*res);
            ans -= t;
            //减去一开始的自己
            t = t*2;
            //每找到一个1会使后面所有情况多出2
            t = t % MOD;
            ans %= MOD;
        }
    }
    cout << ans << endl;
    return 0;
}

4.string函数

之前写过一些，但是又发现了新的函数，导致我天梯赛浪费了一部分时间。

string s2 = s1.erase(0,2);
//s1,s2都会删除索引为0开始的2个字符
    
string s2 = s1.insert(0,"abc");
//s1,s2都会在索引为0的位置插入“abc”

s1.replace(0,2,"abc");
//把s1中的从0开始长度为2的字符替换成“abc”

string s2 = s1.substr(0,2);
//s2会截取s1从0开始的2个字符

string s2;
s2.assign(s1);
//s1的内容重新赋值给s2
s2.assign(s1,1,3);
//s2的内容为s1从1开始的3个字符
//那跟substr函数好像一样一样的诶...

<1>（团队程序设计天梯赛 L1-5）

别再来这么多猫娘了！ 15分

比赛的时候一直t，没办法全过，后来看到群里学长们在讨论才知道，替换词里可能存在违禁词，无限替换循环。题目本身还是很简单的，就不写题解了。下次一定要注意不要直接用替换词！！！尤其是acm赛制！
代码：

#include<iostream>

using namespace std;

string wjc[102];
int main() {
    int n;
    cin >> n;
    for(int i = 0; i < n; i++) {
        cin >> wjc[i];
    }
    int k;
    cin >> k;
    string wb;
    getline(cin,wb);
    getline(cin,wb);
    int res = 0;
    for(int i = 0; i < n; i++) {
        int t = 0;
        t = wb.find(wjc[i],t);
        while(t != -1) {
            wb.erase(t,wjc[i].length());
            wb.insert(t,"?|?|");
            t = wb.find(wjc[i],t);
            res++;
        }
    }
    if(res >= k) {
        cout << res << endl;
        cout << "He Xie Ni Quan Jia!" << endl;
    }
    else {
        int lt = 0;
        lt = wb.find("?|?|",lt);
        while(lt != -1) {
            wb.erase(lt,4);
            wb.insert(lt,"<censored>");
            lt = wb.find("?|?|",lt);
        }
        cout << wb << endl;
    }
    return 0;
}

5.dfs和bfs

<1>（AcWing 843）

y总的课，学了好几次这俩个算法了，dfs搞得差不多了，能写，bfs还是只懂概念，希望下次可以写出来。
题解：

代码：

#include<iostream>

using namespace std;

char a[10][10];
//储存棋盘的状态
int ls[10];
//储存这一列是否有皇后，可以用bool函数
int zx[20];
//储存这一斜是否有皇后
int yx[20];
//储存另一斜是否有皇后
int hs;

void dfs(int n) {
    //n表示遍历到第几行
    if(n == hs) {
        for(int i = 0; i < n; i++) {
            puts(a[i]);
            //直接输出a的这一整行
        }
        puts("");
        //换行输出
        return ;
        //遍历完成
    }
    for(int i = 0; i < hs; i++) {
        if(ls[i] == 0 && zx[i + n] == 0 && yx[hs - n - 1 + i] == 0) {
            //全都没有皇后，这一个位置可以放
            a[n][i] = 'Q';
            ls[i] = zx[i+n] = yx[hs-n-1+i] = 1;
            dfs(n + 1);
            //下一行
            a[n][i] = '.';
            ls[i] = zx[i+n] = yx[hs-n-1+i] = 0;
            //遍历完成恢复状态
        }
        else {
            a[n][i] = '.';
        }
        //可以不写的其实，但不写不知道为什么可以实现要求
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> hs;
    for(int i = 0; i < hs; i++) {
        for(int j = 0; j < hs; j++) {
            a[i][j] = '.';
        }
    }
    dfs(0);
    return 0;
}

6.博弈论

第一次听说这个名词，这应该就是针对这类型题的吧，俩个人互相算计的这种。题倒是看到过好几道了，做出来的是一个都没有。

<1>（四川大学线上校赛 J）

Alice and Bob
三个人做了一晚上也没做出来，最后还拼命掐点交WA，后来是问了学长之后又看了半天代码，似懂非懂。给他改得顺眼了点，又加了点注释。
题解：
黑板上写下2N个整数，以及一个至少为2的整数M，Alice和Bob轮流以最优策略删除数字，如果删除的数字之和mod M相等就是Bob赢，否则就是Alice赢。
大概思路应该是，如果全是偶数个，或者全都是大于2/m的组合并且组合数是偶数的话就是Bob赢，否则全是Alice赢。
代码：

#include<iostream>
#include<vector>
#include<unordered_map>
#include<utility>

#define int long long
#define double long double
using namespace std;

unordered_map<int, int>hm;
//储存数组中每个数字出现的次数
vector<int>ans;
//储存输入的数字

void fun ( vector<int> pp,int m ) {
    int sum = 0;
    for (int i = 0; i < pp.size(); i++) {
        int x=pp[i];
        //vector也可以直接遍历
        hm[x]++;
        if (hm[x] % 2 != 0) {
            sum++;
        } else {
            sum--;
        }
    }
    //sum判断是否所有数字都是偶数个
    if (m % 2 != 0 || sum==0) {
        if (sum)cout << "Alice" << endl;
        else cout << "Bob" << endl;
        return ;
    }
    //如果sum是0的话一定是Bob赢，如果m是奇数的话一定是Alice赢
    pp.clear();
    for ( auto[u,v] : hm ) {
        if ( v % 2 != 0 ) {
            pp.emplace_back ( u % ( m / 2 ));
        }
    }
    //a,b,c,a+m/2,b+m/2,c+m/2的情况
    if ( pp.size() / 2 % 2 != 0 ) {
        //3m 或者 m 都无法/2m
        cout << "Alice" << endl;
        return ;
    }
    else{
        sum = 0;
        for (int i = 0; i < pp.size(); i++) {
            int x = pp[i];
            hm[x]++;
            if ( hm[x] % 2 != 0) {
                sum++;
            } else {
                sum--;
            }
        }
        //同上思维
        if ( sum != 0 ) cout << "Alice" << endl;
        else cout << "Bob" << endl;
    }
    return ;
}

int32_t main() {
    int T = 1;
    while (T--) {
        int n, m;
        cin >> n >> m;
        for (int i = 0; i < 2 * n; i++) {
            int x;
            cin >> x;
            ans.emplace_back(x);
            //与push_back造成的结果相同，但是emplace_back更简便
        }
        fun(ans,m);
        //判断一下谁赢了
    }
    return 0;
}

7.素数

//开根号法
bool IsPrime (int x) {
    if (x <= 1) {
        return false;
    }
    for (int i = 2; i*i <= x; i++) {
        //必须有等于号，例如9；
        if (x % i == 0) return false;
    }
    return true;
}

    //埃拉托斯特尼筛法
    int pri[1000005];
    memset(pri,0,sizeof(pri));
    int n;
    cin >> n;
    for (int i = 2; i*i <= n; i++) {
        if(pri[i] == 0) {
            for (int j = i*i; j <= n; j+=i) {
                //i*i以前的数没有必要算，比i小的数字已经遍历完
                pri[j] = 1;
            }
        }
    }

<1>（CF The 21st Sichuan University Programming Contest I）

这真的是签到题
服了呀三个人做了大几个小时这题，愣是没跑过去，给我无语住了。至今不知道之前几段代码错在了哪里，服气了。
题解：
在数组a中寻找最大的数字ai满足其所有的质因子都在该数列中，如果不存在就输出-1，直接暴力求解见代码。
代码：

#include<iostream>
#include<algorithm>
using namespace std;

int main() {
    int st[1000005] = {0};
    int n;
    cin >> n;
    int a[n];
    for(int i = 0; i < n; i++) {
        cin >> a[i];
        st[a[i]] = 1;
    }
    sort(a,a+n);
    for(int i = n - 1; i >= 0; i--) {
        bool stt = true;
        if(a[i] == a[i+1])continue;
        for (int j = 2; j < a[i]; j++) {
            if(a[i] % j == 0) {
                bool pq = true;
                for (int q = 2; q*q <= j; q++) {
                    if(j % q == 0){
                        pq = false;
                    }
                }
                if(pq){
                    if(!st[j]){
                        stt = false;
                    }
                }
            }
        }
        if(stt){
            cout << a[i] << endl;
            return 0;
        }
    }
    cout << -1 << endl;
    return 0;
}

8.前缀和

一直以为前缀和超简单的，结果这题真就给我绕晕了。

<1>（山东理工ACM D）

会编程的老师

四个小时的比赛三个小时在做这题，然后还没做出来我也是服了。但是它的算法又很简单，不知道这题算是简单还是不简单了。过得人还巨多。
题解：
题目要求给定q次询问字符串xi，在长度为n的字符串s中寻找一个最长的满足xi中每个字符只出现一次的子串，输出最长长度，s只包含九个字符。
利用前缀和思维，储存s中每个位置包含的九个字母的数量，遍历起位置，结尾的位置用二分判断，满足条件的跟前几轮最大res比较，最终输出。具体见注释。
代码：

#include<iostream>
#include<algorithm>
#include<vector>
#include<unordered_map>
#include<map>
using namespace std;

int pre[10][10004];
//储存前缀和
map<char,int>vis;
//用了个map方便查找

int main() {
    vis['P']=0;
    vis['Q']=1;
    vis['Y']=2;
    vis['S']=3;
    vis['Z']=4;
    vis['T']=5;
    vis['M']=6;
    vis['N']=7;
    vis['B']=8;
    
    int n,q;
    cin >> n >> q;
    string s;
    cin >> s;
    s = ' ' + s;
    
    for (int i = 1; i < s.length(); i++) {
        for (int j = 0; j < 9; j++) {
            pre[j][i] = pre[j][i - 1];
            //储存到第i个位置，每个元素j出现几次
        }
        pre[vis[s[i]]][i]++;
        //当前位置出现的得再加上一
    }
    
    while(q--) {
//        cout << "si" << endl;
        string x;
        cin >> x;
        int res = 0;
        //末位置
        for (int i = 1; i < s.length(); i++) {
   //         cout << "aaa" << endl;
            auto check = [&] (int p) {
                bool st = true;
                for (int j = 0; j < x.length(); j++) {
                    if(pre[vis[x[j]]][p] - pre[vis[x[j]]][i - 1] >= 2) {
                        //如果到这个位置特定元素出现不止一次，那就直接放弃这个末尾
                        st = false;
                        return st;
                    }
                }
                return st;
            };//研究了好久，应该是在循环内定义了一个bool函数

    //        cout << "sto[" << endl;
            int l = i, r = s.length() - 1;
            int ans = 0;
            while (l <= r) {
                int  mid = l+r >> 1;
                if (check(mid)) {
                    l = mid + 1;
                    ans = mid;
                    //满足条件的最后一位就是ans
                }
                else r = mid - 1;
            }//一个二分开始判断
            
            if (ans) {
                bool st = true;
                for (int j = 0; j < x.length(); j++) {
                    if(pre[vis[x[j]]][ans] - pre[vis[x[j]]][i - 1] != 1) {
                        //哦！这里在判断这个结尾够不够，有些特定元素还没出现过，就不可以用这个结尾
                        st = false;
                        break;
                    }
                }
                if (st) {
                    res = max (res, ans - i + 1);
                    //正确就继续啦
 //                   cout << ans << ' ' << i << endl;
                }
            }
        }
        
        cout << res << endl;
    }
    return 0;
}

三、总结

前俩周比赛比懵了，好吧不找借口了，一旦不强制，我自己也好久不写题解了，实在不喜欢补题，希望之后稍微自律一点。

FS_tar
关注
SMU-CSE5382:SMU 2016年SpringCES 5382 7382的源代码和材料-计算机图形学-Source material
03-24
“＃SMU-CSE5382” 一些注意事项：该项目应为x64（64位）构建。 32位版本将需要不同版本的GLFW。 没有理由建立32位。 在OSX下，合并时请牢记您的库路径。 如果合并或克隆后遇到链接器错误，请确保正确设置了库路径...
SMU-Hack-A-Week:SMU 的 Hackaweek 网站
06-06
圣玛丽大学 Hack-A-Week 网站 查看当前。 或上的最新信息。 用法 ... 可选：您可以简单地使用 Python。 python -m SimpleHTTPServer ...要生成这些屏幕截图，请参阅 。... 启动一个服务器（ 需要一个服务器来托管文件），...
2024四川省赛 The 2024 Sichuan Provincial Collegiate Programming Contest补题记录
s1379659220的博客
09-27 1069
手玩一个离谱的矩形可以发现,不管怎么给矩形,最后最优的放置(这里找的是当前需要放置的矩形左下角位置)一定是在所有放置过的矩形的右下角的x的集合和y的集合中取出一个(除了初始状态0,0要额外加入),例如,图中的5放在这个位置是最优的了,可以看到5矩形的左下角是落在了3矩形(右下角)的x和2矩形(右下角)的y上,所以每次放置矩形用两个vector存x和y,由于x要尽可能小,所以每次x加入之后要排序。然后是五个数字:2 a b c d(a,b,c,d,e,f同x)
2024年ACM 竞赛班（七：动态规划）
ghc7hHx的博客
05-24 1279
表示走到结点 u 的概率，则对于结点 u 和其子节点 v ，经过结点 v 的概率应该加上经过结点 u 的概率乘u的儿子个数的倒数，对应的期望应该增加这个概率乘边权，最终将所有点的期望相加即可。，用cnt表示已经出现过的非零位置的个数，考虑最高的k个不为零的位置，对于位置 i ，分别枚举该位置可能出现的数，题意：有n堆石子，每次将相邻的两堆合成一堆，新的一堆石子数为合并的体力花费，求将n堆石子合并成一堆的最小花费。表示已经经过的点的集合为state，且最后位于点 j 的路径的最小值，则状态转移方程为。
SMU-ACM Spring 2024 1st
FS_tar的博客
04-22 836
周二oi赛制，蓝桥杯训练，打完就跑了没来得及补题，360分打得很差。周四补题周二的蓝桥杯训练，前俩天网站的几场比赛也都来不及参加。周六蓝桥杯，别的没有了。周日天梯训练，可以说是最简单的一次了，但还是好几题有一个案例没过，调整心态吧，下次直接往后走，别浪费时间了。周六天梯赛，最佳女队和国二。周日CF训练赛。比赛有点多，好几周没写周报了好像，慢慢补题ing。
SMU-ACM集训队2024 2nd
FS_tar的博客
03-24 699
周一打了场cf，晚上实在太困了打得很不好，也没打完，花点时间补题吧。周四整忘了直接开训练了，下次再来。周二打了天梯模拟，反正二十分题及以下题全都做出来了，只做出了一题二十五分题，一个大二的都没打过呢。一些STL根本用不出来，纯暴力手写了。周六成信大天梯赛，前七题八十分我简直无言以对，做题速度太慢，一直在修改，后来也没有时间看别的题目。当然也不会做。周二天梯模拟，周六试了一下电子科大的校赛，微笑点头.jpg。这比赛都不知道有没有补题的必要了。
SMU-ACM集训队2024 3rd
FS_tar的博客
03-31 1843
同上啊周二天梯，有一道题卡了很久但其实不太有价值，还导致我后面的题目做崩了，所以ioi赛制还是很需要注意时间的。周六天梯训练赛，好几题差一俩分没拿满，在举特例方面能力非常薄弱，很多情况都会考虑不到，最后还有一点时间的时候不太想写了，以后也要注意调整状态，坚持到最后一刻。周六晚上atcoder，只做出了ab，c题给我做的WA，RE，TLE就是没AC。周日补题补题补题。有关补题的，补题最好能补到至少俩题25分题.
SMU-ACM集训队 2024 4th
FS_tar的博客
04-07 684
周二蓝桥杯训练，oi赛制盲打了简直，280分，B题不知道怎么个事大家过的乱七八糟反正我没过。周四，做了2023天梯赛，做了俩个半小时125分，不过再多做半个小时也未必能做出来就是了，L1做了一个半小时，L2用了大半个小时做了一道题，但是感觉好歹是能做出来的了，没有排行榜对比但比平时训练好一点点，继续加油。周五蓝桥杯训练，185分打的什么玩意，第一第二题都没过。这赛制也太可怕了吧，改一点点就全对全错了。继续补题中。Segmentation fault（分段错误）其实就是数组越界了。
SMU-ACM集训队2024 1st
FS_tar的博客
03-10 767
开学了，但是感觉每周写博客记录一下自己学了什么挺好的，看看我能不能多坚持一段时间吧，这次就是纯自觉啦。希望还是每周都有新东西。这周好像要打天梯选拔赛？稍微冲一下。周六，开始回顾之前的题目，从第一次的洛谷开始，把题全补了，之前怎么都看不懂题解补不了题，现在可以了，虽然有些还是做不太出来，不过有进步啦嘿嘿。周二打了一次天梯选拔赛，打得人不多看不太出水平其实，有一道题目题意理解错误，一直wa，后来自己补题一次过的，还是得多做一点。持续补题中…又是周六，第二把天梯选拔赛。
SMU_ACM 3.4.2024-3.10.2024
qq_39804992的博客
03-09 379
核心：左移枚举所有情况+按位与判断情况存不存在在有多个变量，每个变量仅有 用与不用 两种情况时，用此方法来列出所有情况@离散数学有m个变量于是有2的m次方种情况，用位运算的方式表示即为：1
SMU Winter 2024 div2 2nd
FS_tar的博客
02-04 2098
基本习惯用clion啦，目前在适应ClangFormat，据说可以规范代码格式。好像这个软件确实是比devC++高级一点点，主要是多熟悉几个编程软件吧，而且目前用的是纯英文的。周一又打了蓝桥杯模拟赛，这次div1和div2是一起的，拿了四十名，422分13.01h，很多在gh的题原来都是前几道了啊，可是我还是不会做，这周给这类型常出题开个板块，大家都好厉害啊。我好像只能做签到题的水平唉。连通域的概念。
Python库 | ams_smu-1.2.0-py3-none-any.whl
04-20
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：ams_smu-1.2.0-py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Deep_Learning:SMU-2021-1
03-22
深度学习 SMU-2021-1
图论-代码随想录刷题记录[JAVA]
lapiii的博客
11-14 754
新手小白记录第一次刷代码随想录1.自用 抽取精简的解题思路 方便复盘2.代码尽量多加注释3.记录踩坑4.边刷边记录，更有成就感！5.解题思路绝大部分来自代码随想录。
DAY63||拓扑排序精讲 |dijkstra（朴素版）精讲
2301_79865280的博客
11-14 703
某个大型软件项目的构建系统拥有 N 个文件，文件编号从 0 到 N - 1，在这些文件中，某些文件依赖于其他文件的内容，这意味着如果文件 A 依赖于文件 B，则必须在处理文件 A 之前处理文件 B （0 <= A, B <= N - 1）。请编写一个算法，用于确定文件处理的顺序。第一行输入两个正整数 N, M。表示 N 个文件之间拥有 M 条依赖关系。后续 M 行，每行两个正整数 S 和 T，表示 T 文件依赖于 S 文件。输出共一行，如果能处理成功，则输出文件顺序，用空格隔开。
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
最新发布
zhaoylzy的博客
11-16 1043
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
java计算文本相似度算法总结
sunsiny
11-14 924
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
1163：阿克曼(Ackmann)函数
呆萌很的博客
11-12 279
1163：阿克曼(Ackmann)函数
Python库 ams_smu-1.2.0 安装指南
资源摘要信息:"Python库 | ams_smu-1.2.0-py3-none-any.whl" 在深入探讨本资源之前，我们首先需要了解几个基础知识点。首先，Python是一种广泛使用的高级编程语言，以其可读性强和简洁的语法著称。Python库是指一组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值