LINK Blog

——互联网里的一粒沙

发表于 分类于 ， 本文字数： 678 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
struct DSU {
  std::vector<int> f, siz;

  DSU() {}
  DSU(int n) { init(n); }

  void init(int n) {
    f.resize(n);
    std::iota(f.begin(), f.end(), 0);
    siz.assign(n, 1);
  }

  int find(int x) {
    while (x != f[x]) {
      x = f[x] = f[f[x]];
    }
    return x;
  }

  bool same(int x, int y) { return find(x) == find(y); }

  // 按秩合并
  void merge(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) {
      return;
    }
    if (x > y)
      f[y] = x;
    else
      f[x] = y;
  }

  /*
  bool merge(int x, int y) {
      x = find(x);
      y = find(y);
      if (x == y) {
          return false;
      }
      siz[x] += siz[y];
      f[y] = x;
      return true;
  }
  */

  int size(int x) { return siz[find(x)]; }
};

发表于 分类于 ， 本文字数： 262 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int primes[N], cnt; // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n) {
  for (int i = 2; i <= n; i++) {
    if (!st[i])
      primes[cnt++] = i;
    for (int j = 0; primes[j] <= n / i; j++) {
      st[primes[j] * i] = true;
      if (i % primes[j] == 0)
        break;
    }
  }
}

发表于 分类于 ， 本文字数： 247 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define sqr(x) ((x) * (x))

auto add = [&](i64 x, i64 y, vector<i64> &p) {
  for (; x <= n; x += lowbit(x))
    p[x] += y;
};

auto query = [&](i64 x, vector<i64> &p) {
  int ans = 0;
  for (; x; x -= lowbit(x))
    ans += p[x];
  return ans;
};

发表于 分类于 ， 本文字数： 418 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
i64 merge_sort(int q[], int l, int r) {
  if (l >= r)
    return 0;

  int mid = l + r >> 1;

  i64 res = merge_sort(q, l, mid) + merge_sort(q, mid + 1, r);

  int k = 0, i = l, j = mid + 1;
  while (i <= mid && j <= r)
    if (q[i] <= q[j])
      tmp[k++] = q[i++];
    else {
      res += mid - i + 1;
      tmp[k++] = q[j++];
    }
  while (i <= mid)
    tmp[k++] = q[i++];
  while (j <= r)
    tmp[k++] = q[j++];

  for (i = l, j = 0; i <= r; i++, j++)
    q[i] = tmp[j];

  return res;
}

发表于 分类于 ， 本文字数： 569 阅读时长 ≈ 1 分钟 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
i64 fpow(i64 a, i64 x) {
  i64 res = 1;
  while (x) {
    if (x & 1)
      res = res * a % mod;
    a = a * a % mod;
    x >>= 1;
  }
  return res % mod;
}

const i64 M = 1e5;
i64 fac[M + 10], fnv[M + 10];

void init() {
  fac[0] = 1;
  for (int i = 1; i <= M; i++)
    fac[i] = fac[i - 1] * i % mod;
  fnv[M] = fpow(fac[M], mod - 2);
  for (int i = M; i >= 1; i--)
    fnv[i - 1] = fnv[i] * i % mod;
  // assert(fnv[1] == 1);
}

i64 C(i64 n, i64 m) {
  if (m < 0 || m > n)
    return 0;
  return fac[n] * fnv[m] % mod * fnv[n - m] % mod;
} // c(n,m)
i64 A(i64 n, i64 m) {
  if (m < 0 || m > n)
    return 0;
  return fac[n] * fnv[m] % mod;
} // a(n,m);

发表于 分类于 本文字数： 1.6k 阅读时长 ≈ 3 分钟

云服务器配置frp（基础篇）

本文基于debian11.3系统，云服务器为阿里云轻量应用服务器。该基础篇仅介绍frp服务基本配置，不涉及具体应用场景。

以下所有代码默认以root身份执行

阅读全文 »

发表于 更新于 分类于 ， 本文字数： 1.6k 阅读时长 ≈ 3 分钟

市场利率化是指利率由市场供求决定，反映资金的稀缺程度和时间价值，对宏观经济均衡和资源配置发挥重要导向作用。市场利率化是经济金融领域最核心的改革之一，也是实现货币政策目标的关键手段。市场利率化的基本要求是建立健全由市场供求决定利率、中央银行通过运用货币政策工具引导市场利率的市场化利率体系。

我国的利率市场化改革始于上世纪90年代初，经过30多年的持续推进，已取得显著成效，形成了比较完整的市场化利率体系，收益率曲线也趋于成熟，为发挥好利率对宏观经济运行的重要调节功能创造了有利条件。我国的利率市场化改革遵循的是“先外币、后本币；先贷款、后存款；先长期、大额，后短期、小额”的循序渐进的改革思路，大致可划分为以下三个阶段1：

  • 第一阶段：货币市场利率市场化，贷款利率开始上浮（1993—1999年）。在这一阶段，我国建立了货币市场，实现了货币市场利率的市场化，同时取消了贷款利率的上限，允许银行根据市场情况对贷款利率进行上浮，但存款利率仍受到严格的管制。
  • 第二阶段：贷款利率市场化，存款利率逐步放开（2000—2013年）。在这一阶段，我国取消了贷款利率的下限，实现了贷款利率的完全市场化，同时逐步放开了存款利率的上限，允许银行对部分存款品种进行上浮，但存款利率的下限仍受到管制。
  • 第三阶段：存款利率市场化，利率传导机制改革（2014年至今）。在这一阶段，我国取消了存款利率的上限，实现了存款利率的完全市场化，同时推进了利率传导机制的改革，包括推出贷款市场报价利率（LPR）作为贷款定价基准，完善利率走廊和政策利率体系，优化央行货币政策工具，提高利率对宏观经济运行的重要调节功能。
阅读全文 »
0%