magicat

RTX5060TI 配置Xinference

2025-10-23T08:57:00+00:00

RTX5060TI 配置Xinference

CUDA

(llama-factory) D:\P\llm\LLaMA-Factory>nvcc -V
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2025 NVIDIA Corporation
Built on Wed_Apr__9_19:29:17_Pacific_Daylight_Time_2025
Cuda compilation tools, release 12.9, V12.9.41
Build cuda_12.9.r12.9/compiler.35813241_0

(llama-factory) D:\P\llm\LLaMA-Factory>nvidia-smi
Thu Oct 23 15:24:02 2025
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 576.88                 Driver Version: 576.88         CUDA Version: 12.9     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                  Driver-Model | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 5060 Ti   WDDM  |   00000000:01:00.0  On |                  N/A |
|  0%   38C    P0             24W /  180W |    2728MiB /  16311MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

配置环境和安装依赖

conda create -n Xinference python=3.10.14
conda activate Xinference
pip install "xinference[all]"
pip uninstall torch torchvision torchaudio -y
pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128 --no-deps

下载模型

在这个网站自助 https://modelscope.cn/

运行Xinference

windows不支持0.0.0.需要使用127.0.0.1 ip的方式

xinference-local –host 0.0.0.0 –port 9997

xinference-local –host 127.0.0.1 –port 9997

Windows下启动Xinference报错 RuntimeError: Cluster is not available after multiple attempts-CSDN博客

npu配置Xinference环境，并部署embedding和rerank模型

2025-10-23T08:32:00+00:00

在我司服务器上部署，但是尝试了其他文章的docker镜像，出现算子错误等问题，后面又用回

参考文献
https://blog.csdn.net/sccum/article/details/145995250
https://blog.csdn.net/qq_41994821/article/details/147223327
https://ascend.readthedocs.io/zh-cn/latest/sources/sentence_transformers/install.html

docker run -it -d --net=host --shm-size=20g  \
  --name Xinf \
  --device /dev/davinci4 \
  --device /dev/davinci5 \
  --device /dev/davinci_manager \
  --device /dev/devmm_svm \
  --device /dev/hisi_hdc \
  -v /usr/local/dcmi:/usr/local/dcmi \
  -v /usr/local/bin/npu-smi:/usr/local/bin/npu-smi \
  -v /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/ \
  -v /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info \
  -v /etc/ascend_install.info:/etc/ascend_install.info \
  -v /root/.cache:/root/.cache \
  -v /share/models/embedding/bge-reranker-v2-m3:/bge-reranker-v2-m3:ro \
  -p 9997:9997 \
  -it $IMAGE bash

# 终端1
export XINFERENCE_ENDPOINT=http://0.0.0.0:9997
xinference-local --host 0.0.0.0 --port 9997
# 终端2
export XINFERENCE_ENDPOINT=http://127.0.0.1:9997
## 本地下载重排序模型之后
xinference launch --model-name bge-reranker-v2-m3 --model-type rerank --model-path /bge-reranker-v2-m3

后面我直接通过打开http://127.0.0.1:9997配置embedding和rerank模型。

RTX 5060TI 部署llama-factory

2025-10-23T07:25:00+00:00

搭建环境

NVIDIA驱动略，CUDA略

(llama-factory) D:\P\llm\LLaMA-Factory>nvcc -V
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2025 NVIDIA Corporation
Built on Wed_Apr__9_19:29:17_Pacific_Daylight_Time_2025
Cuda compilation tools, release 12.9, V12.9.41
Build cuda_12.9.r12.9/compiler.35813241_0

(llama-factory) D:\P\llm\LLaMA-Factory>nvidia-smi
Thu Oct 23 15:24:02 2025
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 576.88                 Driver Version: 576.88         CUDA Version: 12.9     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                  Driver-Model | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 5060 Ti   WDDM  |   00000000:01:00.0  On |                  N/A |
|  0%   38C    P0             24W /  180W |    2728MiB /  16311MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

如果出现环境冲突，请尝试使用pip install –no-deps -e解决

conda create -n llama-factory python=3.11.11
conda activate llama-factory
git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e ".[metrics]"
pip uninstall torch torchvision torchaudio -y
pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install bitsandbytes

(llama-factory) D:\P\llm\LLaMA-Factory>python
Python 3.11.11 | packaged by Anaconda, Inc. | (main, Dec 11 2024, 16:34:19) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> print(torch.__version__)    # '2.9.0+cu128'
2.9.0+cu128
>>> print(torch.cuda.is_available())    # True
True

llamafactory-cli webui

http://localhost:7860/

XCPC最后的故事

2024-09-29T15:21:00+00:00

update：为了学弟的救赎，合作在2024年ICPC昆明和香港拿下铜和银

最后在23年的桂林和济南拿下了两个铜牌，于24年5月在广州打了退役之战

end

换blog了 https://kdk550.github.io/

三轮考核

2023-10-25T03:07:00+00:00

三轮考核

Codeforces游玩攻略 : https://www.luogu.com.cn/blog/ezoixx130/codeforces-tutorial

考核标准：codeforces rating (\geq) 1200

任务：

自行参加codeforces的div.2 3 4的比赛，并赛后补题
设置组织为 Shaoguan University
自行组织每周三，周六，周日下午的训练（我会告诉第1个人，接下来6个人轮流接手），在机房的提交记录可抵扣工作室打卡时长（2h）
有事找我请假
在工作室社交社交
私发我全平台的题量
把自己的codeforces昵称发到群里，
格式：姓名 codeforces昵称
例：t宝 tourist
关于debug，不能运行：一段一段注释程序，直到能运行，即知道错误代码在何处；答案错误：在代码某处打印其变量的值；死循环：解决方法同“不能运行”。在很多情况下，打印变量，注释代码可以解决绝大多数场景的问题
学习主要算法（暂时想到这么多）：
1. 排序
2. 前缀和差分
3. 栈，队列
4. 搜索 dfs bfs
5. 存图，dfs bfs 遍历图
6. 二分查找，二分答案
7. 双指针算法
8. 快速幂
9. 最大公约数，最小公倍数
10. 分解质因数，埃式筛法，线性筛法
11. 逆元（会求就行）

算法

2023-10-10T12:29:00+00:00

学习道路：
1. 通过第一学期的算法学习，顺利成为一名算法竞赛选手。
2. 学习目标：通过科学的方式学习算法，向 ACM-ICPC（是计算机类竞赛最有含金量的比赛）奖牌冲锋
3. 在第二学期参加比赛，比赛中学习，学习中比赛，其中每年能够有多次外出比赛的机会
参加的主要赛事（A类赛事或企业认可度高的赛事）：

比赛	日期	赛制
蓝桥杯	4/6月	OI
天梯赛	4月	IOI
广东省大学生程序设计竞赛	5月	ACM
国际大学生程序设计邀请赛 & 中国大学生程序设计邀请赛	5月	ACM
睿抗	7/8月	IOI
百度之星	8/9月	ACM
国际大学生程序设计区域赛 & 中国大学生程序设计分站赛	10/11月	ACM

C with STL （string，map，set）

C++基础学习网址： https://oi-wiki.org/lang/

Hello, World!
C，C++的输入输出
变量
运算
流程控制语句
高级数据类型
函数
string
map，set(C++ 标准库 -> STL容器 -> 关联式容器)

课后练习做他这个和我们都是一样的，但这个课程配套OJ太老了，还是推荐下面练习的题单

红色圈起来的部分是和考核强相关的，没圈起来并不意味着不重要

位运算

位运算学习网址： https://oi-wiki.org/math/bit/

与、或、异或
取反
左移和右移
复合赋值位运算符
关于优先级
位运算的应用
1. 有关 2 的幂的应用
2. 判断两非零数符号是否相同
3. 换两个数
4. 操作一个数的二进制位
*内建函数（选学）

排序

排序学习网址：https://oi-wiki.org/basic/sort-intro/

冒泡排序
归并排序
桶排序
快速排序
排序相关 STL
*排序应用

Q ：排序的循环，递归都好抽象？我该如何快速掌握排序的算法？

A：学习算法的快速方法就是将程序每次的执行过程打印出来，看出其交换元素或递归区间的改变，详细见代码块。

以冒泡排序为例，在学习其算法思想后，将每一阶段交换的位置及代码打印出来，或对着代码用纸笔模拟排序过程有助于掌握算法。

Q ：好多排序呀！这么多排序算法竞赛真的用的上吗？要不要学那么多，哪个排序最快，是不是会一个就够了？

A ：各种排序都有其独特的应用场景，冒泡排序和归并排序经常处理有关逆序对的问题；归并排序和快速排序用到了分治，递归的思想，学习这个排序是为了初探分治，递归，让自己能写出具有分治和递归的算法；桶排序元素的值映射到数组下标上，在特定应用背景下和后面学习权值线段树中会用到；平时更多用到的是 sort(a + 1, a + 1 + n); ，这个功能很强大，对于string, pair,array,和重载了远算符的结构体也能进行排序，所以会在二轮考核的机试中考核 sort(); ，笔试中考察能否正确描述冒泡排序，归并排序，桶排序，快速排序的思想。

#include 

using namespace std;

int n = 5;
int a[10] = {0, 3, 4, 5, 1, 2};
int main()
{
    cout<<"init array : "<<a[1]<<" "<<a[2]<<" "<<a[3]<<" "<<a[4]<<" "<<a[5]<<'\n';
    cout<<'\n';
    for(int i = 1; i < n; i++)
    {
        for(int j = 1; j <= n - i; j++)
            if(a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);
                cout<<"swap : ";
                cout<<"i : "<<i<<"  j  : "<<j<<'\n';
                cout<<a[1]<<" "<<a[2]<<" "<<a[3]<<" "<<a[4]<<" "<<a[5]<<'\n';
                cout<<'\n';
            }
    }
    cout<<"end sort : "<<a[1]<<" "<<a[2]<<" "<<a[3]<<" "<<a[4]<<" "<<a[5]<<'\n';
    return 0;
}

练习

题单：https://www.luogu.com.cn/training/380528

思维题 : https://www.luogu.com.cn/training/391817#problems

模拟考核 : https://www.luogu.com.cn/training/385785#problems

注意！这个题单是动态更新的，对于题号CF或者AT开头的题目，需要你去题目来源网站注册账号，提交submit

对于不会的题目，可以再想想，也可以看题解或者在群里面问。

2022 China Collegiate Programming Contest (CCPC) Weihai Site EAJGCI

2023-10-07T03:41:00+00:00

2022 China Collegiate Programming Contest (CCPC) Weihai Site

VP概况

这场我一年之前做过，然后就没有去补题，今年重新和新队友们做做这场，开局还算顺利地过了两个签到，然后就是三道铜牌题，曾经一度卡题一个半小时，然后我做出了J，队友做出了数学和计算几何，在正赛算是可以拼手速拿到铜，但还不够，还要多多补题，其实VP的时候C可以写出来的，下蛋就真的不会了

E - Python Will be Faster than C++

模拟，存在 (a_{n - 1} \geq a_n) 无解，其余模拟即可

const int N = 1e7 + 20;
 
int a[N];
void solve()
{       
    int n, k;   cin>>n>>k;
    int i;
    for(i = 1; i <= n; i++)
        cin>>a[i];
    int cnt = 0;
    i = n;
    while(++cnt <= 1e7 && a[n - 1] >= a[n])
    {
        i++;
        a[i] = max(0, 2 * a[i - 1] - a[i - 2]);
        if(a[i] < k)
        {
            cout<<"Python 3."<<i<<" will be faster than C++\n";
            return;            
        }
    }
    cout<<"Python will never be faster than C++\n";
    return;
}

A - Dunai

记录每个位置有多少人，然后算出能组成多少支队伍，再和冠军选手取个min即可，赛时画了柱状图去理解

int n, m, c[10], b[10];
void solve()
{       
    cin>>n;
    set<string> S;
    for(int i = 1; i <= n * 5; i++)
    {
        string s;    cin>>s;
        S.insert(s);
    }
    cin>>m;
    for(int i = 1; i <= m; i++)
    {
        string s;    cin>>s;
        int a;  cin>>a;
        if(S.count(s))
            c[a]++;
        b[a]++;
    }
    int miv = min({b[1], b[2], b[3], b[4], b[5]});
    miv = min({miv, c[1] + c[2] + c[3] + c[4] + c[5]});
    cout<<miv<<'\n';
 
    return;
}

J - Eat, Sleep, Repeat

博弈，但是答案是求最多的操作次数的奇偶性相关

我的做法是对限制为0进行分段，这样就可以确定 (a_i) 最终会出现在哪一段内，对 a 排序，双指针去模拟这个过程

const int N = 3e5 + 20;
 
int a[N];
int n, k;
map<int, int> mp;
vector<int> vx;
set<int> S;
void solve()
{       
    mp.clear();
    vx.clear();
    S.clear();
    cin>>n>>k;
    for(int i = 1; i <= n; i++)
        cin>>a[i];
 
    mp[-1] = 0;
    vx.push_back(-1);
    S.insert(-1);
 
    mp[1000000002] = 0;
    vx.push_back(1000000002);
    S.insert(1000000002);    
    for(int i = 1; i <= k; i++)
    {
        int x, y;   cin>>x>>y;
        mp[x] = y;
        if(y == 0)  
        {
            S.insert(x);
            vx.push_back(x);
        }
    }
    sort(a + 1, a + 1 + n);
    sort(vx.begin(), vx.end());
    int m = vx.size();
    queue<int> q[m + 2];
    for(auto it : vx)
    {
        int p = it + 1;
        for(int l = p; ; l++)
        {
            if(S.count(l))  break;
            if(mp.count(l) == 0)    
            {
                mp[l] = n;
                break;
            }
        }
    }
    for(int i = 1; i <= n; i++)
    {
        int pos = lower_bound(vx.begin(), vx.end(), a[i]) - vx.begin() - 1;
        q[pos].push(a[i]);
    }  
    ll res = 0;
    for(int i = 0; i < m; i++)
    {
        int p = vx[i] + 1;
        for(int l = p; ; l++)
        {
            while(mp[l] != 0 && !q[i].empty() && q[i].front() >= l)
            {
                mp[l]--;
                res += (q[i].front() - l);
                q[i].pop();
            }
            if(q[i].empty())
                break;
        }
    } 
    if(res % 2 == 1)
    {
        cout<<"Pico\n";
    }
    else
        cout<<"FuuFuu\n";
    return;
}

G - Grade 2

打表可以知道答案有循环节，求出这个循环节区间

typedef long long ll;
 
const int mod = 1e9 + 7;
const int N = 2e6 + 10;
 
ll mi = 1, s[N];
 
void init()
{
    ll x;   cin>>x;
    for(; mi <= x; mi *= 2);
    for(int i = 1; i <= mi; i++)
        s[i] = s[i - 1] + (__gcd(i * x ^ x, x) == 1);
}
 
void solve()
{       
    ll l, r;    cin>>l>>r;
    l--;
    ll res = r / mi * s[mi] + s[r % mi] - l / mi * s[mi] - s[l % mi];
    cout<<res<<'\n';
 
    return;
}
 
int main()
{
    ios::sync_with_stdio(false);   cin.tie(nullptr), cout.tie(nullptr);
    
    int TC = 1;
    init();
    cin >> TC;    
    for(int tc = 1; tc <= TC; tc++)
    {
        //cout << "Case #" << tc << ": ";         
        solve();
    }
    return 0;
}

C - Grass

手玩数据可以知道，只要 5 个点不在一条直线上，那么答案一定存在，枚举这 5 个点谁做A点即可

证明看官方题解

int n;
void solve()
{           
 
    cin>>n;
    vector<array<int, 2>> d; 
    for(int i = 1; i <= min(n, 4); i++)
    {
        int x, y;   cin>>x>>y;
        d.push_back({x, y});
    }
    bool ok = false;
    if(n > 4)
    {
        for(int i = 5; i <= n; i++)
        {
            int x, y;   cin>>x>>y;
            d.push_back({x, y});
            for(int j = 0; j < 5; j++)
            {
                set<array<int, 2>> S, a;
                for(int k = 0; k < 5; k++)
                {
                    if(j == k)  continue;
                    int tx = d[k][0] - d[j][0];
                    int ty = d[k][1] - d[j][1];
                    int g = __gcd(abs(tx), abs(ty));
                    tx /= g, ty /= g;
                    S.insert({tx, ty});
                }
                if(S.size() == 4 && ok == false)
                {
                    cout<<"YES\n";
                    cout<<d[j][0]<<" "<<d[j][1]<<'\n';
                    for(int k = 0; k < 5; k++)
                        if(j != k)
                            cout<<d[k][0]<<" "<<d[k][1]<<'\n';
                    ok = true;
                }
            }
            d.pop_back();
        }
    }
    if(!ok)
        cout<<"NO\n";
    return;
}

I - Dragon Bloodline

VP时没思路，认为是dp或者贪心，看了题解发现是贪心，也明白了贪心的正确性，对于每次贪心需要最多的元素，放生产效率最高的工具龙去生产

const int N = 2e5 + 10;
 
int n, k;
ll a[N], b[N], c[N], sb[N];
 
bool check(ll mid)
{
    priority_queue<ll, vector<ll>, less<ll>> q;
    for(int i = 1; i <= n; i++)
        q.push(a[i] * mid);
    for(int i = 0; i < k; i++)
        c[i] = b[i];
    int i = k - 1;
    while(q.size() >= 1)
    {
        ll t = q.top(); q.pop();
        if(i == -1) return false;
        ll need = max({1ll, t / (1 << i)});
        need = min(c[i], need);      
        t = t - need * (1 << i);
        c[i] = c[i] - need;
        if(t >= 1)
            q.push(t);
        if(c[i] == 0)
            i--;
    }
    return true;
}
void solve()
{       
    cin>>n>>k;
    ll l = 0, r = 0, t = 0;
    for(int i = 1; i <= n; i++)
    {
        cin>>a[i];
        t += a[i];
    }
 
    for(int i = 0; i < k; i++)
    {
        cin>>b[i];
        sb[i] = b[i] * (1 << i);
        r += sb[i];
    }
    r /= t;
    while(l < r)
    {
        ll mid = (l + r + 1) >> 1;
        if(check(mid))    l = mid;
        else r = mid - 1;
    }
    cout<<l<<'\n';
    return;
}

2022 China Collegiate Programming Contest (CCPC) Mianyang Onsite GCHMAD

2023-09-28T03:01:00+00:00

2022 China Collegiate Programming Contest (CCPC) Mianyang Onsite

2022 China Collegiate Programming Contest (CCPC) Mianyang Onsite

VP 情况

队友告诉我题意很顺利过了两签到，对着C虚空写法，搞了一个if(n=3)while(1)的样例发现构造假了，然后马上过了，但是罚时很多然后队友过了石头剪刀布，读了A，很快想到了dp和转移方程，但不知道怎么转移好，最后结束比赛了，看了大家用记忆化搜索竟然这么好些，然后补了DM，这个D我想了很久，一直不懂怎么枚举和三分这个赔率，写了好几个版本，直到今天终于想明白了。

G - Let Them Eat Cake

每轮操作删掉一半的数，已得知操作次数最多只有 (\log n) 轮，直接模拟

int n;
const int N = 1e5 + 10;
 
void solve()
{
	cin>>n;
	int res = 0;
	vector<int> a, b;
	for(int i = 1; i <= n; i++)
	{
		int x;	cin>>x;
		b.push_back(x);
	}
	int sz = n;
	while(sz != 1)
	{
		res++;
		a = b;
		b.clear();
		int m = a.size();
		for(int i = 0; i < m; i++)
		{
			// cout<
			// if(i - 1 >= 0)
			// 	cout<
			// if(i + 1 < m)
			// 	cout<
			// cout<<'\n';
			bool ok = false;
			if(i - 1 >= 0 && a[i - 1] > a[i])
			{
				ok = true;
			}
 
			if(i + 1 < m && a[i + 1] > a[i])
				ok = true;
			if(!ok)
				b.push_back(a[i]);
		}
		sz = b.size();
	}
	cout<<res<<'\n';
}

C - Catch You Catch Me

对于1的儿子，其答案是以其儿子为根子树的深度

int n;
const int N = 1e5 + 10;
 
int dep[N], f[N];
vector<int> e[N];
void dfs(int u, int from)
{
	dep[u] = dep[from] + 1;
	f[u] = dep[u];
	for(auto v : e[u])
	{
		if(v == from)	continue;
		dfs(v, u);
		f[u] = max(f[u], f[v]);
	}
}
void solve()
{
	cin>>n;
	for(int i = 1; i < n; i++)
	{
		int u, v;	cin>>u>>v;
		e[u].push_back(v);
		e[v].push_back(u);
	}
	dfs(1, 0);
	long long res = 0;
	for(auto v : e[1])
	{
		res = res + f[v] - 1;
	}
	cout<<res<<'\n';
}

H - Life is Hard and Undecidable, but…

构造方式见代码

ll k;
int dx[] = {1, 1};
int dy[] = {1, 0};
int res[310][310];
void solve()
{
	cin>>k;
	int x = 1, y = 1;
	for(int i = 1; i <= 2 * k; i++)
	{
		x = x + dx[0];
		y = y + dy[0];
		res[x][y] = 1;
	} 	
	int n = 0;
	for(int i = 1; i <= 300; i++)
		for(int j = 1; j <= 300; j++)
			n += res[i][j];
	cout<<n<<'\n';
	for(int i = 1; i <= 300; i++)
		for(int j = 1; j <= 300; j++)
			if(res[i][j] == 1)
				cout<<i<<" "<<j<<'\n';
}

M - Rock-Paper-Scissors Pyramid

观察出有单调栈的特点，根据特点直接去模拟单调栈

const int N = 1e6 + 10;
typedef long long ll;
int n, a[N];
void solve()
{
    string s;   cin>>s;
    n = s.size();
    s = "?" + s;
    for(int i = 1; i <= n; i++)
    {
        if(s[i] == 'S') 
            a[i] = 0;
        else if(s[i] == 'P')    
            a[i] = 1;
        else 
            a[i] = 2;
    }
    stack<int> stk; stk.push(a[1]);
    for(int i = 2; i <= n; i++)
    {
        while(!stk.empty() && a[i] == (stk.top() - 1 + 3) % 3)
            stk.pop();
        stk.push(a[i]);        
    }
    while(stk.size() > 1)
        stk.pop();
    if(stk.top() == 0)
        cout<<"S";
    else if(stk.top() == 1)
        cout<<"P";
    else 
        cout<<"R";
    cout<<'\n';
}

A - Ban or Pick, What’s the Trick

轮流操作，我可以选择选一个我方能力值最大的英雄，也可以禁掉对方能力值最大的英雄

(f_{pos,i,j})状态就是第 (pos) 轮，A选了 (i) 个英雄，(B) 选了 (j) 个英雄，而双方禁用的英雄数量是可以确定的，用记忆化搜索写就行

const int N = 2e5 + 10;
 
typedef long long ll;
 
ll n, k;
ll a[N], b[N];
ll f[2 * N][11][11], tmp;
//  第 pos 次操作, A 选了 j 个, B 选了 p 个
ll dfs(int pos, int i, int j)
{
    if(pos == 2 * n) return 0;
    int dela = i + pos / 2 - j;
    int delb = j + (pos + 1) / 2 - i;
    if(f[pos][i][j] != tmp)
        return f[pos][i][j];
    ll res;
    if(pos % 2 == 0)
    {
        res = -1e18;
        if(dela + 1 <= n && i + 1 <= k)
            res = max(dfs(pos + 1, i + 1, j) + a[dela + 1], res);
        res = max(dfs(pos + 1, i, j), res);
    }
    else
    {
        res = 1e18;
        if(delb + 1 <= n && j + 1 <= k)
            res = min(dfs(pos + 1, i, j + 1) - b[delb + 1], res);
        res = min(dfs(pos + 1, i, j), res);
    }
    f[pos][i][j] = res;
    return res;
}
 
void solve()
{
    cin>>n>>k;
    for(int i = 1; i <= n; i++)
        cin>>a[i];
    for(int i = 1; i <= n; i++)
        cin>>b[i];
    sort(a + 1, a + 1 + n);
    sort(b + 1, b + 1 + n);
    reverse(a + 1, a + 1 + n);
    reverse(b + 1, b + 1 + n);
    memset(f, 0x3f, sizeof f);
    tmp = f[0][0][0];
    cout<<dfs(0, 0, 0)<<'\n';
    // cout<
}

D - Gambler’s Ruin

选择枚举一个队的赔率，三分另一个队的赔率

将两队预测胜率从小到大排序
前缀和处理
枚举A队赔率
三分另一队赔率

这个我很快想到了解法，但是一直不知道怎么处理1,2操作，写了好多个版本一直过不了样例，过了1周再写就过了

typedef long long ll;
 
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
 
map<double, ll> mp;
int n, m;
vector<pair<double, ll>> a, b;
ll sx[N], sy[N];
double res;
double f(int idx, int idy)
{
    double s1 = 1.0 * a[idx].first * sx[idx];
    double s2 = 1.0 * b[idy].first * sy[idy];    
    return 1.0 * sx[idx] + sy[idy] - max(s1, s2); 
}
void work(int idx)
{
    int l = 0, r = m - 1;
    while(l < r)
    {
        int lmid = l + (r - l) / 3;
        int rmid = r - (r - l) / 3;
        double fl = f(lmid, idx), fr = f(rmid, idx);
        if(fl <= fr)
            l = lmid + 1;
        else r = rmid - 1;
        res = max({fl, fr, res});
        // cout<
    }
}
void solve()
{       
    cin>>n;
    for(int i = 1; i <= n; i++)
    {
        double p;   ll c;   cin>>p>>c;
        mp[p] += c;
    }
    a.push_back({0, 0});
    b.push_back({0, 0});
    for(auto [x, y] : mp)
    {
        if(x != 0.0)
            a.push_back({1.0 / x, y});
        if(x != 1.0)
            b.push_back({1.0 / (1.0 - x), y});
    }
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    n = a.size(), m = b.size();
    for(int i = 0; i < n; i++)
    {
        sx[i] = a[i].second;
        if(i >= 1)  sx[i] += sx[i - 1];
    }
    for(int i = 0; i < m; i++)
    {
        sy[i] = b[i].second;
        if(i >= 1)  sy[i] += sy[i - 1];
    }
    for(int i = 0; i < n; i++)
        work(i);
    cout<<fixed<<setprecision(10)<<res<<'\n';
    return;
}

The 2021 China Collegiate Programming Contest (Harbin) JBEIDG

2023-09-27T15:09:00+00:00

The 2021 China Collegiate Programming Contest (Harbin)

The 2021 China Collegiate Programming Contest (Harbin)

VP概况

队友不应该写签到，签到应该我来写，以至于多了 (2) 罚时，后面的题放心交给队友就好。

J - Local Minimum

问矩阵中有多少个元素 (A_{i,j}) 同时是第 (r) 行，第 (c) 列上的最小元素

(n = 1000) 直接暴力

const int N = 1e3 + 10;
ll a[N][N], n, m, res, r[N], c[N];
void solve()
{
	cin>>n>>m;
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++)
			cin>>a[i][j];

	memset(r, 0x3f, sizeof r);
	memset(c, 0x3f, sizeof c);
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++)
			r[i] = min(a[i][j], r[i]);
	for(int j = 1; j <= m; j++)
		for(int i = 1; i <= n; i++)
			c[j] = min(a[i][j], c[j]);	
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++)
			if(a[i][j] == r[i] && a[i][j] == c[j])
				res++;
	cout<<res<<'\n';
}

B - Magical Subsequence

问子序列第 (2 \times i) 元素和第(2 \times i - 1) 位元素的和为 (X) 时，子序列的最大长度是？

定义状态 (f_{i,j}) ，表示第 (i) 位，元素和为 (j) 的子序列最大长度

预处理 (suf_{i,j}) 表示第 (i) 位，后缀中值为 (k) 的元素位置

转移方程：

\[f_{suf_{i,j-a_i},j} = f_{i-1,j} + 2 \]

const int N = 1e5 + 10;
 
int f[N][210];
int a[N], suf[N][110];
 
void solve()
{
	ll n;
	cin>>n;
	for(int i = 1; i <= n; i++)
		cin>>a[i];
	memset(suf, -1, sizeof suf);
	for(int i = n; i >= 1; i--)
	{
		for(int j = 1; j <= 100; j++)
			suf[i][j] = suf[i + 1][j];
		if(i + 1 <= n)
			suf[i][a[i + 1]] = i + 1;
	}
	int res = 0;
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= 200; j++)
			f[i][j] = max(f[i - 1][j], f[i][j]);
		for(int j = a[i] + 1; j <= 200; j++)
		{
			if(j - a[i] > 100)	break;
			int k = j - a[i];
			if(suf[i][k] == -1)	continue;
			f[suf[i][k]][j] = max(f[i - 1][j] + 2, f[suf[i][k]][j]);
			res = max(f[suf[i][k]][j], res);
		}
	}
	cout<<res<<'\n';
}

E - Power and Modulo

考虑到 (a_i \leq 10^9)，那么对于取模来说，在 (n) 足够大的情况下，一定存在

(2^{i - 2} \% m= 2^{i - 2})

(2^{i - 1} \% m= a_i)

const int N = 1e5 + 10;
ll a[N], n;
ll bmi[N];
void solve()
{
	cin>>n;
	for(int i = 1; i <= n; i++)
		cin>>a[i];
	bmi[1] = 1;	
	for(int i = 2; i <= 60; i++)
		bmi[i] = bmi[i - 1] * 2;
	ll m = -1;
 
	for(int i = 1; i <= n; i++)
	{
		// cout<
		if(a[i] == bmi[i])
			continue;
		else
		{
			m = bmi[i] - a[i];
			break;
		}
	}
	// cout<
	if(m == -1)
	{
		cout<<-1<<'\n';
		return;
	}
	bool ok = true;
	ll base = 1 % m;
	for(int i = 1; i <= n; i++)
	{
	 	if(base != a[i])
			ok = false;
		base *= 2;
		base %= m;
	}
	if(ok)
		cout<<m<<'\n';
	else
		cout<<-1<<'\n';
 
}

I - Power and Zero

发现各个二进制位的有多少个，若满足 (cnt_0 \geq cnt_1 \geq \dots \geq cnt_{32}) ，则答案最优，不断去调整即可

const int N = 2e5 + 10;
 
int cnt[40];
void solve()
{       
    memset(cnt, 0, sizeof cnt);
    int n;  cin>>n;
    for(int i = 1; i <= n; i++)
    {
        int x;  cin>>x;
        int t = 0;
        while(x)
        {
            cnt[t++] += (x % 2);
            x /= 2;
        }
    }
    while(1)
    {
        bool ok = false;
        for(int i = 1; i <= 32; i++)
        {
            if(cnt[i] > cnt[i - 1])
            {
                ok = true;
                cnt[i]--;
                cnt[i - 1] += 2;
                break;
            }
        }
        if(!ok)
            break;
    }
    cout<<cnt[0]<<'\n';
    return;
}

D - Math master

用二进制数 (S) 表示分子剩余部分，我们从低位去检查分母即可

#define int __int128
#define ll __int128
 
using namespace std;
 
inline __int128 read(){__int128 x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-'){f=-1;}ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}return x*f;}
inline void write(__int128 x){if (x < 0){putchar('-');x = -x;}if (x > 9) write(x / 10);putchar(x % 10 + '0');}
ll a[50], b[50], c[50];
void solve()
{       
    ll p, q;    
    // cin>>p>>q;
    p = read(), q = read();
    int n = 0, m = 0;
    __int128 t = p;
    while(t)    a[n++] = t % 10, t /= 10;
    t = q;
    while(t)    b[m++] = t % 10, t /= 10;
    for(int S = 0; S < (1 << n); S++)
    {
        ll tp = 0, cnt = 0, d[11];
        memset(d, 0, sizeof d);
        for(int i = n - 1; i >= 0; i--)
            if((S >> i) & 1)
                cnt++, tp = tp * 10 + a[i];
            else    d[a[i]]--;
        __int128 tq =(__int128)tp * q;
        if(tq % p != 0 || tp == 0)  continue;
        tq /= p;
        t = tq;
        int j = 0;
        for(int i = 0; i < m; i++)
            if(b[i] == t % 10)
                j++, t /= 10;
            else 
                d[b[i]]++;
        bool ok = true;
        for(int i = 0; i <= 9; i++)
            if(d[i] != 0)   ok = false;
        if(ok && t == 0 && tq != 0 && tp != 0)
            q = min(q, (ll)tq), p = min(p, (ll)tp);                
    }
    write(p);   cout<<" ";  write(q);
    cout<<'\n';
    return;
}

G - Damaged Bicycle

(P_S) 记录集合内单车都是坏的

官方题解：

(f_{i,S}) 为访问 (S) 集合内的单车，最终停在 (i) 号点的最小期望时间，访问 (i) 之前就找到了好单车、(i) 是第一辆好单车、(i) 还是坏的。

#include

using namespace std;

typedef long long ll;

const int N = 1e5 + 10;
int t, r;
int n, m;
vector<pair<int, int>> e[N];
int k;
int pos[N];
bool vis[N];
double p[20];
int d[20][N];
void dij(int id, int start)
{
    priority_queue<pair<int,int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
    memset(vis, false, sizeof vis);
    for(int i = 1; i <= n; i++)
        d[id][i] = 1e9;
    d[id][start] = 0;
    q.push({0, start});
    while(q.size() >= 1)
    {
        auto t = q.top();       q.pop();
        int u = t.second;
        if(vis[u])   continue;
        vis[u] = true;
        for(auto [v, w] : e[u])
        {
            if(d[id][v] > d[id][u] + w)
            {
                d[id][v] = d[id][u] + w;
                q.push({d[id][v], v});
            }
        }
    }
}
double f[20][1 << 20];
double P[1 << 20];
void solve()
{
    cin>>t>>r;
    cin>>n>>m;
    for(int i = 1; i <= m; i++)
    {
        int u, v, w;    
        cin>>u>>v>>w;
        e[u].push_back({v, w});
        e[v].push_back({u, w});
    }
    cin>>k;
    p[0] = 1.0;
    pos[0] = 1;
    for(int i = 1; i <= k; i++)
    {
        cin>>pos[i]>>p[i];
        p[i] = p[i] / 100;
        if(pos[i] == 1)
        {
            p[0] = p[i]; 
            i--, k--;
        }
    }
    for(int i = 0; i <= k; i++)
        dij(i, pos[i]);

    if(d[0][n] >= 1e9)
    {
        cout<<-1<<'\n';
        return;
    }
    double res = p[0] * d[0][n] / t + (1.0 - p[0]) * d[0][n] / r;
    for(int S = 1; S < (1 << k); S++)
    {
        P[S] = p[0];
        for(int j = 0; j < k; j++)
            f[j][S] = 1e15;
        for(int j = 0; j < k; j++)
            if((S >> j) & 1) 
                P[S] *= p[j + 1];
    }
    for(int j = 0; j < k; j++)
    {
        f[j][1 << j] = p[0] * d[0][pos[j + 1]] / t;
        f[j][1 << j] += (1 - p[0]) * d[0][n] / r;
        f[j][1 << j] += p[0] * (1 - p[j + 1]) * d[j + 1][n] / r;
        res = min(f[j][1 << j] + P[1 << j] * d[j + 1][n] / t, res);
    }

    for(int S = 1; S < (1 << k); S++)
    {
        for(int i = 0; i < k; i++)
        {
            if(((S >> i) & 1) == 0) continue;
            for(int j = 0; j < k; j++)
            {
                if(((S >> j) & 1) == 0 || i == j) continue;
                f[i][S] = min(f[j][S ^ (1 << i)] + P[S ^ (1 << i)] * d[j + 1][pos[i + 1]] / t, f[i][S]);
            }
            f[i][S] += P[S ^ (1 << i)] * (1 - p[i + 1]) * d[i + 1][n] / r;
            res = min(f[i][S] + P[S] * d[i + 1][n] / t, res);
        }
    }
    cout<<fixed << setprecision(10) <<res<<'\n';
    // printf("%.10lf\n", res);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    solve();
}

极光工作室

2023-09-27T14:39:00+00:00

极光算法二轮考核

极光算法二轮考核

算法端概况

获奖情况：算法端曾荣获蓝桥杯国一3次、国二和国三多次，今年首次参加的比赛获得：睿抗国一，中国高校计算机大赛——团体程序设计天梯赛团队及个人国三，百度之星银奖等。
学习道路：
1. 通过第一学期的算法学习，顺利成为一名算法竞赛选手。
2. 学习目标：通过科学的方式学习算法，向 ACM-ICPC（是计算机类竞赛最有含金量的比赛）奖牌冲锋。
3. 在第二学期参加比赛，比赛中学习，学习中比赛，其中每年能够有多次外出公费比赛的机会（深圳，广州，北京，杭州，沈阳等）。
参加的主要赛事（A类赛事或企业认可度高的赛事）：

比赛	日期	赛制
蓝桥杯	4/6月	OI
天梯赛	4月	IOI
广东省大学生程序设计竞赛	5月	ACM
国际大学生程序设计邀请赛 & 中国大学生程序设计邀请赛	5月	ACM
睿抗	7/8月	IOI
百度之星	8/9月	ACM
国际大学生程序设计区域赛 & 中国大学生程序设计分站赛	10/11月	ACM

### 考核内容

机试，洛谷平台比赛IOI赛制：https://www.luogu.com.cn/
笔试，描述冒泡排序，归并排序，桶排序，快速排序的思想及应用，不需要写出代码