盛日辉的博客
0%

发表于 更新于 分类于

题目

https://www.lanqiao.cn/problems/196/learning/

思路

  1. 所有操作都是在数组内进行的，整个数组的和不变；
  2. 每次操作的三个数的和不变，因此考虑到用前缀和。
  3. 一次更新后，s[i-1]变为原来的s[i],s[i]变为原来的s[i-1],s[i+1]不变；
  4. 因此“一次加减操作”转变为“前两个前缀和的交换”。
  5. 两端的武士不向外传递灵能，但他们的灵能值也会改变，而s[n]是所有的和，不变。因此，s[0]=0，s[1]到s[n-1]可以交换到任意位置。
  6. 要求的东西就变成了求max{|s[i]-s[i-1|}尽量小。
  7. 先考虑简单情况，s[]都是正的，将他排序，相邻差最大的就是结果，因为如果不排序，相邻相减会大；
  8. https://blog.csdn.net/xuxiaobo1234/article/details/108095193
  9. 最后一步，我只能理解成：小于s[0]大于min部分的值要排列起来，使得相邻两数的差最大值最小化，从图像上想象就是，s[0]固定住，s[1]到s[p]（假设是这样的下标）升序排序，但都小于s[0]，然后隔一个的将数拆开成两部分，一部分降序地排列在s[0]后面，然后另一部分更在后面，这样能“使得相邻两数的差最大值最小化”。

代码

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
# 灵能传输

T = int(input())
for _ in range(T):
    n = int(input())
    arr = list(map(int, input().split()))
    # 计算前缀和
    s = [0] * (n + 1)
    for i, x in enumerate(arr):
        s[i + 1] = s[i] + x
    s0, sn = s[0], s[-1]
    if s0 > sn:
        s0, sn = sn, s0
    # print(s)
    s.sort()
    s0_idx = s.index(s0)
    sn_idx = s.index(sn)
    # print(s)
    # print(s0_idx)
    # print(sn_idx)
    res_sum = s.copy()
    L, R = 0, n
    vis = [True] * (n + 1)
    for i in range(s0_idx, -1, -2):
        res_sum[L] = s[i]
        L += 1
        vis[i] = False
    for i in range(sn_idx, n + 1, 2):
        res_sum[R] = s[i]
        R -= 1
        vis[i] = False
    for i in range(n + 1):
        if vis[i]:
            res_sum[L] = s[i]
            L += 1

    res = 0
    for i in range(1, len(res_sum)):
        res = max(res, abs(res_sum[i] - res_sum[i - 1]))

    print(res)

发表于 更新于 分类于

扫地机器人

题目：https://www.lanqiao.cn/problems/199/learning/

  • 每个机器人“负责”的区域（包括他自己的）*2=他的时间
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
# n, k = map(int, input().split())
# # n, k = 10, 3
# arr = [False] * (n + 1)
#
# for i in range(k):
#     arr[int(input())] = True
#
#
# # for i in [5, 2, 10]:
# #     arr[i] = True
#
#
# def check(d):
#     i = 1
#     while i <= n:
#         # print(d, i, i + d, arr[i:i + d])
#         if not any(arr[i:i + d]):
#             return False
#         i += d
#     return True
#
#
# l, r = 1, n
# while l < r:
#     mid = (l + r) // 2
#     print(l, r, mid)
#     if check(mid):
#         r = mid
#     else:
#         l = mid + 1
# print((l - 1) * 2)


n, k = map(int, input().split())
a = [0]
for i in range(k):
    a.append(int(input()))
a.sort()

print(a)


def check(d):
    len = 0  # 覆盖长度，从最左端开始一直到最右端
    for i in range(1, k + 1):
        if len + d >= a[i]:  # 当前覆盖长度加上d之后，是否包括了a[i]
            if len > a[i]:  # 当前覆盖长度是否已经包括了a[i]
                # 如果当前覆盖长度已经包括了，说明a[i]之前的机器人已经负责了到len这块的区域
                # 那a[i]就可以负责len往后再加d的部分
                len = a[i] + d - 1  # 减1是因为还要算上自己
            else:
                # 如果当前覆盖长度没有包括a[i]，那就让a[i]负责[len+1,len+d]
                len += d
        else:
            return False
    return len >= n


l, r = 1, n
mid = 0
while l < r:
    mid = (l + r) // 2
    print(l, r, mid)
    if check(mid):
        r = mid
    else:
        l = mid + 1
print((l - 1) * 2)

发表于 更新于 分类于

参数

  • x——输入的信号
  • fs——采样率，默认$2\pi$，正数标量
  • t——时间，向量，或者是datetime类型duration类型的数据，或者表示每个样本之间差值
  • type——用什么方式计算，可选是'power' (default) | 'spectrogram' | 'persistence'

以下是要写出名字的参数：

  • FrequencyLimits——频带限制

    默认；[0 fs/2] 二元向量

  • FrequencyResolution — Frequency resolution bandwidth频率分辨率

    实数标量，不能和时间分辨率一起指定。

  • Leakage— Spectral leakage 泄漏量

    默认0.5

  • MinThreshold— Lower bound for nonzero values 非零值的下限

    默认 -Inf

  • NumPowerBins — Number of power bins for persistence spectrum

    默认256

  • OverlapPercent — Overlap between adjoining segments 重叠率

    [0,100)

  • Reassign — Reassignment option 重新分配？？

    默认 false

  • TimeResolution 时间分辨率

  • TwoSided — Two-sided spectral estimate

Spectrogram Computation spectrogram的计算

To compute the time-dependent spectrum of a nonstationary signal, pspectrum divides the signal into overlapping segments, windows each segment with a Kaiser window, computes the short-time Fourier transform, and then concatenates the transforms to form a matrix. For more information, see Spectrogram Computation with Signal Processing Toolbox.

A nonstationary signal is a signal whose frequency content changes with time. The spectrogram of a nonstationary signal is an estimate of the time evolution of its frequency content. To construct the spectrogram of a nonstationary signal, pspectrum follows these steps:

  1. Divide the signal into equal-length segments. The segments must be short enough that the frequency content of the signal does not change appreciably within a segment. The segments may or may not overlap.

  2. Window each segment and compute its spectrum to get the short-time Fourier transform.

  3. Use the segment spectra to construct the spectrogram:

    • If called with output arguments, concatenate the spectra to form a matrix.
    • If called with no output arguments, display the power of each spectrum in decibels segment by segment. Depict the magnitudes side-by-side as an image with magnitude-dependent colormap.
阅读全文 »

发表于 更新于 分类于

安装

安装完之后在环境目录D:\Users\11200\anaconda3\envs\web下会有：

创建项目

终端

  1. 进入终端
  2. 进入想把项目放在的目录下
  3. 执行命令django-admin startproject 项目名
    django-admin要进入这个环境当中。

pycharm创建

选好解释器，删除templates文件夹，将57行改为'DIRS': [],，为了和终端创建的保持一致。

阅读全文 »

发表于 更新于 分类于

题目

1706. 球会落何处
难诉：中等

用一个大小为 m x n 的二维网格 grid 表示一个箱子。你有 n 颗球。箱子的顶部和底部都是开着的。

箱子中的每个单元格都有一个对角线挡板，跨过单元格的两个角，可以将球导向左侧或者右侧。

  • 将球导向右侧的挡板跨过左上角和右下角，在网格中用 1 表示。
  • 将球导向左侧的挡板跨过右上角和左下角，在网格中用 -1 表示。

在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 "V" 形图案，或者被一块挡导向到箱子的任意一侧边上，就会卡住。

返回一个大小为 n 的数组 answer ，其中 answer[i] 是球放在顶部的第 i 列后从底部掉出来的那一列对应的下标，如果球卡在盒子里，则返回 -1 。

 

阅读全文 »

发表于 更新于 分类于

题目

1719. 重构一棵树的方案数
难度：困难

给你一个数组 pairs ，其中 pairs[i] = [xi, yi] ，并且满足：

  • pairs 中没有重复元素
  • xi < yi

令 ways 为满足下面条件的有根树的方案数：

  • 树所包含的所有节点值都在 pairs 中。
  • 一个数对 [xi, yi] 出现在 pairs 中 当且仅当 xi 是 yi 的祖先或者 yi 是 xi 的祖先。
  • 注意：构造出来的树不一定是二叉树。

两棵树被视为不同的方案当存在至少一个节点在两棵树中有不同的父节点。

请你返回：

阅读全文 »

发表于 更新于 分类于

欧拉公式

$ e^{i\theta} = \cos\theta + i\sin\theta$ ，当 $\theta=\pi$ 时，$e^{i\pi} + 1 =0$.

证明一：求导

设 $f(\theta)=\frac{e^i\theta}{i\sin\theta+\cos\theta}$ ,对 $ f(\theta)$ 求一阶导，

因为 $f’(\theta)=0$ ，所以 $f(\theta)$ 是一个常数。取$\theta=0$:

所以，$e^{i\theta} = \cos\theta + i\sin\theta$。
同时，也容易得到 $e^{i\theta} $ 和 $ \cos\theta + i\sin\theta$ 都不等于0。
将 $f(\theta)$ 设为 $f(\theta)=\frac{i\sin\theta+\cos\theta}{e^i\theta}$ 是一样的。

证明二：函数幂级数展开

泰勒展开式和麦克劳林展开式的简单推导
阅读全文 »

发表于 更新于 分类于

题目

969. 煎饼排序

难度：中等

给你一个整数数组 arr ，请使用 煎饼翻转 完成对数组的排序。

一次煎饼翻转的执行过程如下：

  • 选择一个整数 k ，1 <= k <= arr.length
  • 反转子数组 arr[0...k-1]（下标从 0 开始）

例如，arr = [3,2,1,4] ，选择 k = 3 进行一次煎饼翻转，反转子数组 [3,2,1] ，得到 arr = [1,2,3,4] 。

以数组形式返回能使 arr 有序的煎饼翻转操作所对应的 k 值序列。任何将数组排序且翻转次数在 10 * arr.length 范围内的有效答案都将被判断为正确。

阅读全文 »

发表于 更新于 分类于

题目

688. 骑士在棋盘上的概率
难度：中等

在一个 n x n 的国际象棋棋盘上，一个骑士从单元格 (row, column) 开始，并尝试进行 k 次移动。行和列是 从 0 开始 的，所以左上单元格是 (0,0) ，右下单元格是 (n - 1, n - 1) 。

象棋骑士有8种可能的走法，如下图所示。每次移动在基本方向上是两个单元格，然后在正交方向上是一个单元格。

每次骑士要移动时，它都会随机从8种可能的移动中选择一种(即使棋子会离开棋盘)，然后移动到那里。

骑士继续移动，直到它走了 k 步或离开了棋盘。

返回 骑士在棋盘停止移动后仍留在棋盘上的概率 。

阅读全文 »

发表于 更新于 分类于

题目

2029.石子游戏 IX 难度：中等

Alice 和 Bob 再次设计了一款新的石子游戏。现有一行 n 个石子，每个石子都有一个关联的数字表示它的价值。给你一个整数数组 stones ，其中 stones[i] 是第 i 个石子的价值。

Alice 和 Bob 轮流进行自己的回合，Alice 先手。每一回合，玩家需要从 stones 中移除任一石子。

  • 如果玩家移除石子后，导致 所有已移除石子 的价值 总和 可以被 3 整除，那么该玩家就 输掉游戏 。
  • 如果不满足上一条，且移除后没有任何剩余的石子，那么 Bob 将会直接获胜（即便是在 Alice 的回合）。

假设两位玩家均采用 最佳 决策。如果 Alice 获胜，返回 true ；如果 Bob 获胜，返回 false 。

 

示例 1：

阅读全文 »

发表于 更新于 分类于

B站视频：https://www.bilibili.com/video/BV1Yb411a7ty?spm_id_from=333.999.0.0

安装配置hexo
  1. 安装nodejs和npm
    nodejs网站：nodejs.org
    可以用nodejs -v npm -v检查是否安装成功
  2. 安装淘宝镜像cnpm
    npm install -g cnpm --registry=https://registry.npm.taobao.org
    -g全局安装
    cnpm -v检查是否安装成功
  3. 安装hexo框架
    cnpm install -g hexo-cli
    hexo -v
搭建博客
  1. 新建一个文件夹， 进入该文件夹，hexo init
  2. 或者 hexo init (名字);
  3. 启动 start/service
    hexo s
  4. 清理一下
    hexo clean
  5. 生成
    hexo g
  6. 安装git插件
    cnpm install --save hexo-deployer-git
  7. 上传
    hexo d
    简单点可以和生成一起：hexo g -d
  8. 标签页
    hexo n page tags

发表于 更新于 分类于

题目

1221. 分割平衡字符串
难度：简单

在一个 平衡字符串 中，'L' 和 'R' 字符的数量是相同的。

给你一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。

注意：分割得到的每个字符串都必须是平衡字符串。

返回可以通过分割得到的平衡字符串的 最大数量 。

 

示例 1：

阅读全文 »

发表于 更新于 分类于

nvcc -v 查看cuda版本
nvidia-smi 查看cuda版本
这俩有些区别

pip安装
pip3 install torch==1.9.0+cu111 torchvision==0.10.0+cu111 torchaudio===0.9.0 -f https://download.pytorch.org/whl/torch_stable.html

conda
NOTE: ‘conda-forge’ channel is required for cudatoolkit 11.1
conda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c conda-forge

https://pytorch.org/

发表于 更新于 分类于

题目

787. K 站中转内最便宜的航班
难度：中等

有 n 个城市通过一些航班连接。给你一个数组 flights ，其中 flights[i] = [fromi, toi, pricei] ，表示该航班都从城市 fromi 开始，以价格 pricei 抵达 toi。

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到出一条最多经过 k 站中转的路线，使得从 src 到 dst 的 价格最便宜 ，并返回该价格。 如果不存在这样的路线，则输出 -1。

 

示例 1：

示例 2：

 

阅读全文 »