LesSu Hexo http://lessugarr.com/ All rights reserved 2026, LesSu Acmer | CS Sophomore 2026-04-17T04:39:46.761Z LesSu # [题目链接]

# 题目大意

一句话概括。

# 核心思路

  1. 关键性质：(比如：异或和的最高位决定胜负)
  2. 算法选择：(比如：博弈论 + SG 函数)

# 易错点 / 坑点

# AC 代码

点击查看代码(放入代码)
]]> http://lessugarr.com/2026/04/17/%E5%8D%9A%E5%BC%88%E8%AE%BA1/ 2026-04-17T04:39:46.000Z # [题目链接]

# 题目大意]]>

博弈论1 2026-04-17T04:39:46.761Z LesSu # 补题

# 题目链接：左右脑互博 HDU1004

# 题目大意

核心玩法： 给定一个包含 n 个正整数的集合，两人轮流从集合中取走一个数 aia_i，满足：

  • aia_i>(剩余元素的异或和)
  • 若集合只剩 1 个数，可直接取走。
  • 无法操作者输。

# 核心思路

  1. 关键性质：n 很小，考虑状态压缩，再结合只要对于当前状态，可以转移到至少一个必败态，则当前状态为必胜态，否则为必败态，可解
  2. 算法选择：状态压缩 + 记忆化搜索

# 易错点 / 坑点

  • 点击查看代码
    for (int i = 0; i < n; i++)
       {
           if (((u >> i) & 1) && (a[i + 1] > (now ^ a[i + 1])))
           {
               if (dfs(u ^ (1 << i), now ^ a[i + 1]) == 0)
               {
                   dp[u] = 1;
                   break;
               }
           }
       }

# AC 代码

点击查看代码#include #define int long long#define endl '\n'using namespace std;

const int N = 2e6 + 10;
int a[30], dp[N], vis[N];
int s = 0;
int n;
bool dfs(int u, int now)
if (u == 0) return 0; if (vis[u]) return dp[u]; vis[u] = 1; dp[u] = 0; for (int i = 0; i < n; i++) { if (((u >> i) & 1) && (a[i + 1] > (now 【 a[i + 1]))) { if (dfs(u ^ (1 << i), now ^ a[i + 1]) == 0) { dp[u] = 1; break; 】
}
}
return dp[u];
}
void solve()
{

cin >> n;s = 0;for (int i = 1; i <= n; i++){    cin >> a[i];    s ^= a[i];}int t = 1 << n;int ans = dfs(t - 1, s);if (ans)    cout << "Left" << endl;else    cout << "Right" << endl;

}
signed main()
{
cin.tie(0)->ios::sync_with_stdio(0);
int T;
cin >> T;
while (T–)
solve();
return 0;
}

]]> http://lessugarr.com/2026/04/13/HDU%E6%98%A5%E5%AD%A3%E8%81%94%E8%B5%9B%E7%AC%AC%E5%9B%9B%E5%9C%BA/ 2026-04-13T08:36:46.000Z # 补题

# 曼哈顿距离：

d(A,B)=∣x1−x2∣+∣y1−y2∣d(A, B) = |x_1 - x_2| + |y_1 - y_2|

# 切比雪夫距离（棋盘距离）：

d(A,B)=max⁡(∣x1−x2∣,∣y1−y2∣)d(A, B) = \max(|x_1 - x_2|, |y_1 - y_2|)

常用坐标系转换

# 曼哈顿距离转切比雪夫距离

$ (x, y) \rightarrow (x + y, x - y) $

原点 A(x1,y1)A(x_1, y_1) 和 B(x2,y2)B(x_2, y_2) 的曼哈顿距离等于新点 A′A' 和 B′B' 的切比雪夫距离： $$ |x_1 - x_2| + |y_1 - y_2| = \max (|(x_1+y_1) - (x_2+y_2)|, |(x_1-y_1) - (x_2-y_2)|) $$

# 切比雪夫距离转曼哈顿距离

(x,y)→(x+y2,x−y2)(x, y) \rightarrow \left(\frac{x + y}{2}, \frac{x - y}{2}\right)

原点 A(x1,y1)A(x_1, y_1) 和 B(x2,y2)B(x_2, y_2) 的切比雪夫距离等于新点 A′A' 和 B′B' 的曼哈顿距离： $$ \max (|x_1 - x_2|, |y_1 - y_2|) = \left|\frac {x_1+y_1}{2} - \frac {x_2+y_2}{2}\right| + \left|\frac {x_1-y_1}{2} - \frac {x_2-y_2}{2}\right| $$

]]> http://lessugarr.com/2026/04/10/%E8%B7%9D%E7%A6%BB%E5%B0%8F%E8%AE%B0/ 2026-04-10T08:30:12.000Z # 曼哈顿距离：

# 图论

# 1. 拓扑排序（ Kahn 算法）

const int N = 1505;
vector<int> e[N], tp;
int d[N]; // 存每个点的入度
bool topo(int n)
{
    queue<int> q;
    for (int i = 1; i <= n; i++)
    {
        if (!d[i])
            q.push(i);
    }
    while (!q.empty())
    {
        int u = q.front();
        tp.push_back(u);
        q.pop();
        for (auto i : e[u])
        {
            d[i]--;
            if (!d[i]) // 入度为 0，压入队列
                q.push(i);
        }
    }
    if (tp.size() == n)
        return 1;
    else
        return 0;
}
void solve()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int u, v; // 从 u 指向 v 有边
        e[u].push_back(v), d[v]++;
    }
    topo(n); // 是 1 是无环，可以输出拓扑序列，是 0 则有向图有环
}

时间复杂度：O（n+m）O（n+m）

# 2. 迪杰斯特拉最短路

#define int long long
#define INF LLONG_MAX
const int N = 1505;
struct node
{
    int v, w; // 点 边的长度（权）
};
vector<node> e[N];
int dis[N]; // 存每个点到 s 点的最短距离
bool vis[N];
int n, m;
void dij(int s) // 找从 s 点开始到每个点的最短距离
{
    for (int i = 0; i <= n; i++)
        dis[i] = INF;
    dis[s] = 0;
    for (int i = 1; i < n; i++)
    {
        int u = 0;
        for (int j = 1; j <= n; j++)
        {
            if (!vis[j] && dis[u] > dis[j]) // 找一个距离 s 点最近且没有被访问过的点
                u = j;
        }
        vis[u] = 1;
        for (auto i : e[u]) // 访问这个 u 点的每个邻点
        {
            if (dis[i.v] > dis[u] + i.w)
                dis[i.v] = dis[u] + i.w;
        }
    }
}
void solve()
{
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int u, v, w; // u 和 v 之间有长度为 w 的边
        cin >> u >> v >> w;
        e[u].push_back({v, w});
        e[v].push_back({u, w});// 无向图时写
    }
}

时间复杂度：O（n2n^2）

大根堆优化版本：

(大根堆堆顶是最大的元素！)

#define int long long#define INF LLONG_MAXconst int N = 1505;struct node{    int v, w; // 点 边的长度（权）};vector<node> e[N];int dis[N]; // 存每个点到s点的最短距离bool vis[N];int n, m;void dij(int s) // 大根堆优化版{    for (int i = 1; i <= n; i++) // 初始化        dis[i] = INF, vis[i] = 0;    dis[s] = 0;    priority_queue<pair<int, int>> q; // first存值用于排序，second为结点    // priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q; 小根堆定义方法补充    q.push({0, s});    while (!q.empty())    {        auto ed = q.top();        q.pop();        if (vis[ed.second])            continue;        vis[ed.second] = 1;        for (auto i : e[ed.second])        {            if (dis[i.v] > dis[ed.second] + i.w)            {                dis[i.v] = dis[ed.second] + i.w;                q.push({-dis[i.v], i.v}); // 大根堆，正距离的相反数越大，实际距离越小，堆顶元素为距离s最近的结点            }        }    }}void solve(){    cin >> n >> m;    for (int i = 0; i < m; i++)    {        int u, v, w; // u和v之间有长度为w的边        cin >> u >> v >> w;        e[u].push_back({v, w});        e[v].push_back({u, w}); // 无向图时写    }}

时间复杂度：O（mlognmlogn）

# 3. 贝尔曼 - 福特（Bellman-Ford）最短路

Dijkstra：快，但不能正确处理带有负权重边的图
Bellman-Ford：慢，但可以正确处理带有负权重边的图且能检测出负权环
#define int long long
#define INF LLONG_MAX // 不能用 LLONG_MAX 来 memset
const int N = 1505;
struct node
{
    int v, w; // 点 边的长度（权）
};
vector<node> e[N];
int dis[N]; // 存每个点到 s 点的最短距离
bool vis[N];
int n, m;
void bellmanford(int s) // 找从 s 点开始到每个点的最短距离
{
    for (int i = 1; i <= n; i++) // 初始化
        dis[i] = INF;
    dis[s] = 0;
    bool flag; // 用来判断每一轮是否有 “松弛” 的点，没有的画算法停止
    for (int i = 1; i <= n; i++)
    {
        flag = 0;
        for (int u = 1; u <= n; u++)
        {
            if (dis[u] == INF) // 还没有被更新
                continue;
            for (auto x : e[u])
            {
                if (dis[x.v] > dis[u] + x.w)
                {
                    dis[x.v] = dis[u] + x.w;
                    flag = 1;
                }
            }
        }
        if (!flag)
            break;
    }
}
void solve()
{
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int u, v, w; // u 和 v 之间有长度为 w 的边
        cin >> u >> v >> w;
        e[u].push_back({v, w});
        e[v].push_back({u, w}); // 无向图时写
    }
}

时间复杂度O(n∗m)O(n*m)

优化版（SPFA）：

#define int long long
#define INF LLONG_MAX
const int N = 1505;
struct node
{
    int v, w; // 点 边的长度（权）
};
vector<node> e[N];
int dis[N], cnt[N]; // 存每个点到 s 点的最短距离
bool vis[N];
int n, m;
bool spfa(int s) // Bellman-Ford 优化版
{
    for (int i = 1; i <= n; i++) // 初始化
        dis[i] = INF, vis[i] = 0, cnt[i] = 0;
    dis[s] = 0;
    queue<int> q;
    q.push(s);
    vis[s] = 1;
    while (!q.empty())
    {
        auto ed = q.front();
        q.pop();
        vis[ed] = 0;
        for (auto i : e[ed])
        {
            int v = i.v, w = i.w;
            if (dis[v] > dis[ed] + w)
            {
                dis[v] = dis[ed] + w;
                cnt[v] = cnt[ed] + 1; // 记录边数
                if (cnt[v] >= n)      // 存在负环
                    return 1;
                if (!vis[v])
                    q.push(v), vis[v] = 1;
            }
        }
    }
    return 0;
}
void solve()
{
    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        int u, v, w; // u 和 v 之间有长度为 w 的边
        cin >> u >> v >> w;
        e[u].push_back({v, w});
        e[v].push_back({u, w}); // 无向图时写
    }
}
时间复杂度：最坏为 O（n∗mn*m）
在遇到判断负环、存在负边时要用 SPFA
# * 全源最短路
n 次贝尔曼、n 次迪杰、Floyd（全源算法） or Johnson（全源算法）
# 4.Floyd（弗洛伊德）算法（动态规划）（全源最短路）
const int N = 105;
int dp[N][N], p[N][N]; // dp 来计算路径，p 来存插点
int n;
void floyd()
{
    for (int k = 1; k <= n; k++)
    {
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                if (dp[i][j] > dp[i][k] + dp[k][j])
                    p[i][j] = k;
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
            }
        }
    }
}
void path(int i, int j) // 输出最短路径
{
    if (p[i][j] == 0)
        return;
    int k = p[i][j];
    path(i, k);
    cout << k << " ";
    path(k, j);
}
 // 初始化
    //i != j, 无边 ->d[i][j] = INF 有边 d[i][j] = Wij
    //i = j,d[i][j] = 0;
# 5. 约翰逊（Johnson）算法（spfa 的改造 可求负边权）
# 6.Tarjan 强连通分量
struct node
{
    int v, w;
};
const int N = 1010;
vector<node> e[N];
map<PII, int> cc;
int dis[N];
bool vis[N];
int n, m;
int dfn[N], low[N], cnt = 0, id[N], now = 0;
stack<int> s;
void tarjan(int u)
{
    dfn[u] = low[u] = ++cnt;
    s.push(u);
    vis[u] = 1;
    for (auto it : e[u])
    {
        if (!dfn[it.v])
        {
            tarjan(it.v);
            low[u] = min(low[u], low[it.v]);
        }
        else if (vis[it.v])
            low[u] = min(low[u], dfn[it.v]);
    }
    if (dfn[u] == low[u])
    {
        while (1)
        {
            auto it = s.top();
            s.pop();
            id[it] = id[u];
            if (it == u)
                break;
            vis[it] = 0;
        }
        now++;
    }
}
]]>
    
    http://lessugarr.com/2026/04/10/%E5%9B%BE%E8%AE%BA/
    
    2026-04-10T01:27:43.962Z
    
      # 图论


    

    图论1
    2026-04-17T05:19:15.942Z
  
  
    
      LesSu
    
    
      # Who am I?
你好，我是 LesSu！目前是一名大二在读的 CS 学生，也是一名 ACMer（努力沉淀中！）
未来的大学学习日记、补题、算法练习都要在这里留下印记（真的会坚持吗（））
# 🚀 Competitive Programming
PlatformHandleRating
CodeforcesLesSu
AtCoderLesSugarR
  • Training Plan: 每周三、周六固定训练，其余时间 Upsolving / 学习算法
  • Specialty: 努力修整中…
“The best time to plant a tree was 10 years ago. The second best time is now.”
]]>
    
    http://lessugarr.com/2026/04/10/About-Me/
    
    2026-04-10T01:16:59.711Z
    
      # Who am I?

你好，我是 LesSu！目前是一名大二在读的 CS 学生，也是一名 <]]>
    

    About Me
    2026-04-17T05:08:12.019Z