.

懒人链接【所有资料合集】：https://sj.zhangyile.site/
.

.
备用地址【所有资料合集】： https://sj.zhangyile.site/
.
{dotted startColor="#ff6c6c" endColor="#1989fa"/}

1.长期更新。

坚持三到四天一次更新，一般都会晚上及时更新，偶尔看到的比较好的资源也会丢进来。

2.资源多样。

乐乐收录了尽可能多的最近的试卷，还有电子教辅资料，也有各地真题分类汇编，还有一些投机之类的答题模板（武功秘籍），还有各科的讲义（推荐自行分辨质量）。还有一些写作素材，难点突破.....但网站呢，还是主要以各地试卷为主，便于自己刷题和有需要的人下载（还想要啥留言区尽管提！）

3.坚持中高质量。

一般都选择至少能看清字的，不是非常模糊的放进来，字都难以辨别的统统过滤掉，尽力保证自己和别人写的时候舒服一点。一些讲义资料能丢docx就放docx，也方便有需要的人自行整理编辑。

4.免费下载。

啊，对对对，不收费，学习资料收费还有啥意思捏，各个资料需要自取【目前状态还能撑一段时间】，如果能有赞助的，"臣不胜犬马怖惧之情，谨拜表以闻"。毕竟一个人肝网站，有些难度简直是简直了

6.提供预览+直链。

网站【主线路】用的是阿里的在线office viewer，方便下载前判断试卷和资料质量。
第二个文件夹是【备用线路】这边仅仅提供直接下载，两个线路我会尽量保证内容同步！

6.多学长学姐帮助。

哎嘿，想不到吧，暗中也有人支持捏！也在此感谢所有参与帮助的人！

最后 愿各位所有的努力和期待，都能不负光阴不负卿万事可期！

{dotted startColor="#ff6c6c" endColor="#1989fa"/}
{lamp/}

5.上方懒人链接合集！1

{dotted startColor="#ff00ea" endColor="#1989fa"/}

祝高考上岸捏！

★【聚精会神】 学习工作必备的背景音乐★

{anote icon="fa-music" href="https://music.163.com/#/playlist?id=2829821753" type="secondary" content="原歌单链接"/}
{music-list id="7756225924" color="#1989fa" /}

• 快速排序算法模板 —— 模板题 AcWing 785. 快速排序

  void quick_sort(int q[], int l, int r)
  {
    if (l >= r) return;
  
    int i = l - 1, j = r + 1, x = q[l
   + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
  }

• 归并排序算法模板 —— 模板题 AcWing 787. 归并排序

  void merge_sort(int q[], int l, int r)
  {
    if (l >= r) return;
  
    int mid = l + r >> 1;
    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 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];
  }

• 整数二分算法模板 —— 模板题 AcWing 789. 数的范围

  bool check(int x) {/* ... */} // 检查x是否满足某种性质
  
  // 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
  int bsearch_1(int l, int r)
  {
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
  }
  // 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
  int bsearch_2(int l, int r)
  {
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
  }

• 浮点数二分算法模板 —— 模板题 AcWing 790. 数的三次方根

  bool check(double x) {/* ... */} // 检查x是否满足某种性质
  
  double bsearch_3(double l, double r)
  {
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
  }

• 高精度加法 —— 模板题 AcWing 791. 高精度加法

  // C = A + B, A >= 0, B >= 0
  vector<int> add(vector<int> &A, vector<int> &B)
  {
    if (A.size() < B.size()) return add(B, A);
  
    vector<int> C;
    int t = 0;
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];
        if (i < B.size()) t += B[i];
        C.push_back(t % 10);
        t /= 10;
    }
    
    if (t) C.push_back(t);
    return C;
  }

• 高精度减法 —— 模板题 AcWing 792.

  // C = A - B, 满足A >= B, A >= 0, B >= 0
  vector<int> sub(vector<int> &A, vector<int> &B)
  {
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i ++ )
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }
  
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
  }

• 高精度乘法 —— 模板题 AcWing 793. 高精度乘法

  // C = A * b, A >= 0, b >= 0
  vector<int> mul(vector<int> &A, int b)
  {
    vector<int> C;
  
    int t = 0;
    for (int i = 0; i < A.size() || t; i ++ )
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }
    
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    
    return C;
  }

• 高精度除以低精度 —— 模板题 AcWing 794. 高精度除法

  // A / b = C ... r, A >= 0, b > 0
  vector<int> div(vector<int> &A, int b, int &r)
  {
    vector<int> C;
    r = 0;
    for (int i = A.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(), C.end());
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
  }

• 一维前缀和 —— 模板题 AcWing 795. 前缀和

  S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 1]

• 二维前缀和 —— 模板题 AcWing 796. 子矩阵的和

  S[i, j] = 第i行j列格子左上部分所有元素的和

• 以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：

  S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]

• 一维差分 —— 模板题 AcWing 797. 差分

  给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c

• 二维差分 —— 模板题 AcWing 798. 差分矩阵

  给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：
  S[x1, y1] += c, S[x2 + 1, y1] -= c, S[x1, y2 + 1] -= c, S[x2 + 1, y2 + 1] += c

• 位运算 —— 模板题 AcWing 801. 二进制中1的个数

  求n的第k位数字: n >> k & 1
  返回n的最后一位1：lowbit(n) = n & -n

• 双指针算法 —— 模板题 AcWIng 799. 最长连续不重复子序列, AcWing 800. 数组元素的目标和

  for (int i = 0, j = 0; i < n; i ++ )
  {
    while (j < i && check(i, j)) j ++ ;
  
    // 具体问题的逻辑
  }

  常见问题分类：
  (1) 对于一个序列，用两个指针维护一段区间
  (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

• 离散化 —— 模板题 AcWing 802. 区间和

  vector<int> alls; // 存储所有待离散化的值
  sort(alls.begin(), alls.end()); // 将所有值排序
  alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素
  
  // 二分求出x对应的离散化的值
  int find(int x) // 找到第一个大于等于x的位置
  {
    int l = 0, r = alls.size() - 1;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
  }

• 区间合并 —— 模板题 AcWing 803. 区间合并

  // 将所有存在交集的区间合并
  void merge(vector<PII> &segs)
  {
    vector<PII> res;
  
    sort(segs.begin(), segs.end());
    
    int st = -2e9, ed = -2e9;
    for (auto seg : segs)
        if (ed < seg.first)
        {
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);
    
    if (st != -2e9) res.push_back({st, ed});
    
    segs = res;
  }

常用模板二：数据结构

• 单链表 —— 模板题 AcWing 826. 单链表

// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;

// 初始化
void init()
{
    head = -1;
    idx = 0;
}

// 在链表头插入一个数a
void insert(int a)
{
    e[idx] = a, ne[idx] = head, head = idx ++ ;
}

// 将头结点删除，需要保证头结点存在
void remove()
{
    head = ne[head];
}

• 双链表 —— 模板题 AcWing 827. 双链表

  // e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
  int e[N], l[N], r[N], idx;
  
  // 初始化
  void init()
  {
    //0是左端点，1是右端点
    r[0] = 1, l[1] = 0;
    idx = 2;
  }
  
  // 在节点a的右边插入一个数x
  void insert(int a, int x)
  {
    e[idx] = x;
    l[idx] = a, r[idx] = r[a];
    l[r[a]] = idx, r[a] = idx ++ ;
  }
  
  // 删除节点a
  void remove(int a)
  {
    l[r[a]] = l[a];
    r[l[a]] = r[a];
  }

• 栈 —— 模板题 AcWing 828. 模拟栈

  // tt表示栈顶
  int stk[N], tt = 0;
  
  // 向栈顶插入一个数
  stk[ ++ tt] = x;
  
  // 从栈顶弹出一个数
  tt -- ;
  
  // 栈顶的值
  stk[tt];
  
  // 判断栈是否为空，如果 tt > 0，则表示不为空
  if (tt > 0)
  {
  
  }

• 队列 —— 模板题 AcWing 829. 模拟队列

• 普通队列：

  // hh 表示队头，tt表示队尾
  int q[N], hh = 0, tt = -1;
  
  // 向队尾插入一个数
  q[ ++ tt] = x;
  
  // 从队头弹出一个数
  hh ++ ;
  
  // 队头的值
  q[hh];
  
  // 判断队列是否为空，如果 hh <= tt，则表示不为空
  if (hh <= tt)
  {
  
  }

• 循环队列

  // hh 表示队头，tt表示队尾的后一个位置
  int q[N], hh = 0, tt = 0;
  
  // 向队尾插入一个数
  q[tt ++ ] = x;
  if (tt == N) tt = 0;
  
  // 从队头弹出一个数
  hh ++ ;
  if (hh == N) hh = 0;
  
  // 队头的值
  q[hh];
  
  // 判断队列是否为空，如果hh != tt，则表示不为空
  if (hh != tt)
  {
  
  }

• 单调栈 —— 模板题 AcWing 830. 单调栈
  常见模型：找出每个数左边离它最近的比它大/小的数

  int tt = 0;
  for (int i = 1; i <= n; i ++ )
  {
    while (tt && check(stk[tt], i)) tt -- ;
    stk[ ++ tt] = i;
  }

• 单调队列 —— 模板题 AcWing 154. 滑动窗口
  常见模型：找出滑动窗口中的最大值/最小值

  int hh = 0, tt = -1;
  for (int i = 0; i < n; i ++ )
  {
    while (hh <= tt && check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口
    while (hh <= tt && check(q[tt], i)) tt -- ;
    q[ ++ tt] = i;
  }

• KMP —— 模板题 AcWing 831. KMP字符串

  // s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
  求模式串的Next数组：
  for (int i = 2, j = 0; i <= m; i ++ )
  {
    while (j && p[i] != p[j + 1]) j = ne[j];
    if (p[i] == p[j + 1]) j ++ ;
    ne[i] = j;
  }
  
  // 匹配
  for (int i = 1, j = 0; i <= n; i ++ )
  {
    while (j && s[i] != p[j + 1]) j = ne[j];
    if (s[i] == p[j + 1]) j ++ ;
    if (j == m)
    {
        j = ne[j];
        // 匹配成功后的逻辑
    }
  }

• Trie树 —— 模板题 AcWing 835. Trie字符串统计

  int son[N][26], cnt[N], idx;
  // 0号点既是根节点，又是空节点
  // son[][]存储树中每个节点的子节点
  // cnt[]存储以每个节点结尾的单词数量
  
  // 插入一个字符串
  void insert(char *str)
  {
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];
    }
    cnt[p] ++ ;
  }
  
  // 查询字符串出现的次数
  int query(char *str)
  {
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
  }

• 并查集 —— 模板题 AcWing 836. 合并集合, AcWing 837. 连通块中点的数量
  (1)朴素并查集：

    int p[N]; //存储每个点的祖宗节点
    
    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    
    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;
    
    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
  

(2)维护size的并查集：

    int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
    
    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    
    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }
    
    // 合并a和b所在的两个集合：
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);

(3)维护到祖宗节点距离的并查集：

    int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离
    
    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x)
        {
            int u = find(p[x]);
            d[x] += d[p[x]];
            p[x] = u;
        }
        return p[x];
    }
    
    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[i] = 0;
    }
    
    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
    d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

• 堆 —— 模板题 AcWing 838. 堆排序, AcWing 839. 模拟堆

  // h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
  // ph[k]存储第k个插入的点在堆中的位置
  // hp[k]存储堆中下标是k的点是第几个插入的
  int h[N], ph[N], hp[N], size;
  
  // 交换两个点，及其映射关系
  void heap_swap(int a, int b)
  {
    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a], hp[b]);
    swap(h[a], h[b]);
  }
  
  void down(int u)
  {
    int t = u;
    if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
    if (u != t)
    {
        heap_swap(u, t);
        down(t);
    }
  }
  
  void up(int u)
  {
    while (u / 2 && h[u] < h[u / 2])
    {
        heap_swap(u, u / 2);
        u >>= 1;
    }
  }
  
  // O(n)建堆
  for (int i = n / 2; i; i -- ) down(i);

• 一般哈希 —— 模板题 AcWing 840. 模拟散列表
  (1) 拉链法

    int h[N], e[N], ne[N], idx;
  
    // 向哈希表中插入一个数
    void insert(int x)
    {
        int k = (x % N + N) % N;
        e[idx] = x;
        ne[idx] = h[k];
        h[k] = idx ++ ;
    }
    
    // 在哈希表中查询某个数是否存在
    bool find(int x)
    {
        int k = (x % N + N) % N;
        for (int i = h[k]; i != -1; i = ne[i])
            if (e[i] == x)
                return true;
    
        return false;
    }

  (2) 开放寻址法

    int h[N];
  
    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    int find(int x)
    {
        int t = (x % N + N) % N;
        while (h[t] != null && h[t] != x)
        {
            t ++ ;
            if (t == N) t = 0;
        }
        return t;
    }

• 字符串哈希 —— 模板题 AcWing 841. 字符串哈希
  核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
  小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

  typedef unsigned long long ULL;
  ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64
  
  // 初始化
  p[0] = 1;
  for (int i = 1; i <= n; i ++ )
  {
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
  }
  
  // 计算子串 str[l ~ r] 的哈希值
  ULL get(int l, int r)
  {
    return h[r] - h[l - 1] * p[r - l + 1];
  }

• C++ STL简介

  vector, 变长数组，倍增的思想
    size()  返回元素个数
    empty()  返回是否为空
    clear()  清空
    front()/back()
    push_back()/pop_back()
    begin()/end()
    []
    支持比较运算，按字典序
  
  pair<int, int>
    first, 第一个元素
    second, 第二个元素
    支持比较运算，以first为第一关键字，以second为第二关键字（字典序）
  
  string，字符串
    size()/length()  返回字符串长度
    empty()
    clear()
    substr(起始下标，(子串长度))  返回子串
    c_str()  返回字符串所在字符数组的起始地址
  
  queue, 队列
    size()
    empty()
    push()  向队尾插入一个元素
    front()  返回队头元素
    back()  返回队尾元素
    pop()  弹出队头元素
  
  priority_queue, 优先队列，默认是大根堆
    size()
    empty()
    push()  插入一个元素
    top()  返回堆顶元素
    pop()  弹出堆顶元素
    定义成小根堆的方式：priority_queue<int, vector<int>, greater<int>> q;
  
  stack, 栈
    size()
    empty()
    push()  向栈顶插入一个元素
    top()  返回栈顶元素
    pop()  弹出栈顶元素
  
  deque, 双端队列
    size()
    empty()
    clear()
    front()/back()
    push_back()/pop_back()
    push_front()/pop_front()
    begin()/end()
    []
  
  set, map, multiset, multimap, 基于平衡二叉树（红黑树），动态维护有序序列
    size()
    empty()
    clear()
    begin()/end()
    ++, -- 返回前驱和后继，时间复杂度 O(logn)
  
    set/multiset
        insert()  插入一个数
        find()  查找一个数
        count()  返回某一个数的个数
        erase()
            (1) 输入是一个数x，删除所有x   O(k + logn)
            (2) 输入一个迭代器，删除这个迭代器
        lower_bound()/upper_bound()
            lower_bound(x)  返回大于等于x的最小的数的迭代器
            upper_bound(x)  返回大于x的最小的数的迭代器
    map/multimap
        insert()  插入的数是一个pair
        erase()  输入的参数是pair或者迭代器
        find()
        []  注意multimap不支持此操作。 时间复杂度是 O(logn)
        lower_bound()/upper_bound()
  
  unordered_set, unordered_map, unordered_multiset, unordered_multimap, 哈希表
    和上面类似，增删改查的时间复杂度是 O(1)
    不支持 lower_bound()/upper_bound()， 迭代器的++，--
  
  bitset, 圧位
    bitset<10000> s;
    ~, &, |, ^
    >>, <<
    ==, !=
    []
  
    count()  返回有多少个1
    
    any()  判断是否至少有一个1
    none()  判断是否全为0
    
    set()  把所有位置成1
    set(k, v)  将第k位变成v
    reset()  把所有位变成0
    flip()  等价于~
    flip(k) 把第k位取反

常用模板三：搜索与图论

• 树与图的存储

  树是一种特殊的图，与图的存储方式相同。
  对于无向图中的边ab，存储两条有向边a->b, b->a。
  因此我们可以只考虑有向图的存储。

(1) 邻接矩阵：g[a][b] 存储边a->b

(2) 邻接表：

// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
int h[N], e[N], ne[N], idx;

// 添加一条边a->b
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// 初始化
idx = 0;
memset(h, -1, sizeof h);

• 树与图的遍历
  时间复杂度$$O(n+m)$$，$$n$$表示点数，$$m$$表示边数
  (1) 深度优先遍历 —— 模板题 AcWing 846. 树的重心

  int dfs(int u)
  {
    st[u] = true; // st[u] 表示点u已经被遍历过
  
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j]) dfs(j);
    }
  }

  (2) 宽度优先遍历 —— 模板题 AcWing 847. 图中点的层次

  queue<int> q;
  st[1] = true; // 表示1号点已经被遍历过
  q.push(1);
  
  while (q.size())
  {
    int t = q.front();
    q.pop();
  
    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true; // 表示点j已经被遍历过
            q.push(j);
        }
    }
  }

• 拓扑排序 —— 模板题 AcWing 848. 有向图的拓扑序列
  时间复杂度$$ O(n+m)$$,$$n$$表示点数，$$m$$表示边数

  bool topsort()
  {
    int hh = 0, tt = -1;
  
    // d[i] 存储点i的入度
    for (int i = 1; i <= n; i ++ )
        if (!d[i])
            q[ ++ tt] = i;
    
    while (hh <= tt)
    {
        int t = q[hh ++ ];
    
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (-- d[j] == 0)
                q[ ++ tt] = j;
        }
    }
    
    // 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
    return tt == n - 1;
  }

• 朴素dijkstra算法 —— 模板题 AcWing 849. Dijkstra求最短路 I
  时间复杂是 $$O(n2+m),n$$表示点数，$$m$$表示边数

  int g[N][N];  // 存储每条边
  int dist[N];  // 存储1号点到每个点的最短距离
  bool st[N];   // 存储每个点的最短路是否已经确定
  
  // 求1号点到n号点的最短路，如果不存在则返回-1
  int dijkstra()
  {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
  
    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
    
        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    
        st[t] = true;
    }
    
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
  }

• 堆优化版dijkstra —— 模板题 AcWing 850. Dijkstra求最短路 II
  时间复杂度$$ O(mlogn),n$$表示点数，$$m$$表示边数

  typedef pair<int, int> PII;
  
  int n;      // 点的数量
  int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
  int dist[N];        // 存储所有点到1号点的距离
  bool st[N];     // 存储每个点的最短距离是否已确定
  
  // 求1号点到n号点的最短距离，如果不存在，则返回-1
  int dijkstra()
  {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});      // first存储距离，second存储节点编号
  
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
    
        int ver = t.second, distance = t.first;
    
        if (st[ver]) continue;
        st[ver] = true;
    
        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
  }

• Bellman-Ford算法 —— 模板题 AcWing 853. 有边数限制的最短路
  时间复杂度 $$O(nm),n$$表示点数，$$m$$表示边数
  注意在模板题中需要对下面的模板稍作修改，加上备份数组，详情见模板题。

  int n, m;       // n表示点数，m表示边数
  int dist[N];        // dist[x]存储1到x的最短路距离
  
  struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
  {
    int a, b, w;
  }edges[M];
  
  // 求1到n的最短路距离，如果无法从1走到n，则返回-1。
  int bellman_ford()
  {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
  
    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i ++ )
    {
        for (int j = 0; j < m; j ++ )
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)
                dist[b] = dist[a] + w;
        }
    }
    
    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
  }

• spfa 算法（队列优化的Bellman-Ford算法） —— 模板题 AcWing 851. spfa求最短路
  时间复杂度 平均情况下$$O(m)$$，最坏情况下 $$O(nm),n$$表示点数，$$m$$表示边数

  int n;      // 总点数
  int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
  int dist[N];        // 存储每个点到1号点的最短距离
  bool st[N];     // 存储每个点是否在队列中
  
  // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
  int spfa()
  {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
  
    queue<int> q;
    q.push(1);
    st[1] = true;
    
    while (q.size())
    {
        auto t = q.front();
        q.pop();
    
        st[t] = false;
    
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
  }

• spfa判断图中是否存在负环 —— 模板题 AcWing 852. spfa判断负环
  时间复杂度是$$O(nm),n$$表示点数，$$m$$表示边数

  int n;      // 总点数
  int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
  int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
  bool st[N];     // 存储每个点是否在队列中
  
  // 如果存在负环，则返回true，否则返回false。
  bool spfa()
  {
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
  
    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }
    
    while (q.size())
    {
        auto t = q.front();
        q.pop();
    
        st[t] = false;
    
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    
    return false;
  }

• floyd算法 —— 模板题 AcWing 854. Floyd求最短路
  时间复杂度是 $$O(n^3), n$$表示点数
  初始化：

    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;
  
  // 算法结束后，d[a][b]表示a到b的最短距离
  void floyd()
  {
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
  }

• 朴素版prim算法 —— 模板题 AcWing 858. Prim算法求最小生成树
  时间复杂度是$$ O(n2+m),n$$表示点数，$$m$$表示边数

  int n;      // n表示点数
  int g[N][N];        // 邻接矩阵，存储所有边
  int dist[N];        // 存储其他点到当前最小生成树的距离
  bool st[N];     // 存储每个点是否已经在生成树中
  
  
  // 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
  int prim()
  {
    memset(dist, 0x3f, sizeof dist);
  
    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
    
        if (i && dist[t] == INF) return INF;
    
        if (i) res += dist[t];
        st[t] = true;
    
        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }
    
    return res;
  }

• Kruskal算法 —— 模板题 AcWing 859. Kruskal算法求最小生成树
  时间复杂度是$$O(mlogm),n$$表示点数，$$m$$表示边数

  int n, m;       // n是点数，m是边数
  int p[N];       // 并查集的父节点数组
  
  struct Edge     // 存储边
  {
    int a, b, w;
  
    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
  }edges[M];
  
  int find(int x)     // 并查集核心操作
  {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
  }
  
  int kruskal()
  {
    sort(edges, edges + m);
  
    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集
    
    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
    
        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }
    
    if (cnt < n - 1) return INF;
    return res;
  }

• 染色法判别二分图 —— 模板题 AcWing 860. 染色法判定二分图
  时间复杂度是$$ O(n+m),n$$表示点数，$$m$$表示边数

  int n;      // n表示点数
  int h[N], e[M], ne[M], idx;     // 邻接表存储图
  int color[N];       // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色
  
  // 参数：u表示当前节点，c表示当前点的颜色
  bool dfs(int u, int c)
  {
    color[u] = c;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (color[j] == -1)
        {
            if (!dfs(j, !c)) return false;
        }
        else if (color[j] == c) return false;
    }
  
    return true;
  }
  
  bool check()
  {
    memset(color, -1, sizeof color);
    bool flag = true;
    for (int i = 1; i <= n; i ++ )
        if (color[i] == -1)
            if (!dfs(i, 0))
            {
                flag = false;
                break;
            }
    return flag;
  }

• 匈牙利算法 —— 模板题 AcWing 861. 二分图的最大匹配
  时间复杂度是$$ O(nm), n$$表示点数，$$m$$表示边数

  int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
  int h[N], e[M], ne[M], idx;     // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
  int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
  bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过
  
  bool find(int x)
  {
    for (int i = h[x]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true;
            if (match[j] == 0 || find(match[j]))
            {
                match[j] = x;
                return true;
            }
        }
    }
  
    return false;
  }
  
  // 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
  int res = 0;
  for (int i = 1; i <= n1; i ++ )
  {
    memset(st, false, sizeof st);
    if (find(i)) res ++ ;
  }

常用模板四：数学知识

• 试除法判定质数 —— 模板题 AcWing 866. 试除法判定质数

  bool is_prime(int x)
  {
    if (x < 2) return false;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
            return false;
    return true;
  }

• 试除法分解质因数 —— 模板题 AcWing 867. 分解质因数

  void divide(int x)
  {
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
  }

• 朴素筛法求素数 —— 模板题 AcWing 868. 筛质数

  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]) continue;
        primes[cnt ++ ] = i;
        for (int j = i + i; j <= n; j += i)
            st[j] = true;
    }
  }

• 线性筛法求素数 —— 模板题 AcWing 868. 筛质数

  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;
        }
    }
  }

• 试除法求所有约数 —— 模板题 AcWing 869. 试除法求约数

  vector<int> get_divisors(int x)
  {
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
  }

• 约数个数和约数之和 —— 模板题 AcWing 870. 约数个数, AcWing 871. 约数之和
  `如果 N = p1^c1 p2^c2 ... *pk^ck
  约数个数： $$(c1 + 1) * (c2 + 1) * ... * (ck + 1)$$
约数之和： $$(p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)$$

• 欧几里得算法 —— 模板题 AcWing 872. 最大公约数

  int gcd(int a, int b)
  {
    return b ? gcd(b, a % b) : a;
  }

• 求欧拉函数 —— 模板题 AcWing 873. 欧拉函数
  �6�7`cpp
  int phi(int x)
  {
  int res = x;
  for (int i = 2; i <= x / i; i ++ )

    if (x % i == 0)
    {
        res = res / i * (i - 1);
        while (x % i == 0) x /= i;
    }

  if (x > 1) res = res / x * (x - 1);

  return res;
  }

• 筛法求欧拉函数 —— 模板题 AcWing 874. 筛法求欧拉函数

  int primes[N], cnt;     // primes[]存储所有素数
  int euler[N];           // 存储每个数的欧拉函数
  bool st[N];         // st[x]存储x是否被筛掉
  
  
  void get_eulers(int n)
  {
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])
        {
            primes[cnt ++ ] = i;
            euler[i] = i - 1;
        }
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0)
            {
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
  }

• 快速幂 —— 模板题 AcWing 875. 快速幂

  求 m^k mod p，时间复杂度 O(logk)。
  
  int qmi(int m, int k, int p)
  {
    int res = 1 % p, t = m;
    while (k)
    {
        if (k&1) res = res * t % p;
        t = t * t % p;
        k >>= 1;
    }
    return res;
  }

• 扩展欧几里得算法 —— 模板题 AcWing 877. 扩展欧几里得算法

  // 求x, y，使得ax + by = gcd(a, b)
  int exgcd(int a, int b, int &x, int &y)
  {
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a/b) * x;
    return d;
  }

• 高斯消元 —— 模板题 AcWing 883. 高斯消元解线性方程组
  �6�7`cpp
  // aN是增广矩阵
  int gauss()
  {
  int c, r;
  for (c = 0, r = 0; c < n; c ++ )
  {

    int t = r;
    for (int i = r; i < n; i ++ )   // 找到绝对值最大的行
        if (fabs(a[i][c]) > fabs(a[t][c]))
            t = i;
  
    if (fabs(a[t][c]) < eps) continue;
  
    for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);      // 将绝对值最大的行换到最顶端
    for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];      // 将当前行的首位变成1
    for (int i = r + 1; i < n; i ++ )       // 用当前行将下面所有的列消成0
        if (fabs(a[i][c]) > eps)
            for (int j = n; j >= c; j -- )
                a[i][j] -= a[r][j] * a[i][c];
  
    r ++ ;

  }

  if (r < n)
  {

    for (int i = r; i < n; i ++ )
        if (fabs(a[i][n]) > eps)
            return 2; // 无解
    return 1; // 有无穷多组解

  }

  for (int i = n - 1; i >= 0; i -- )

    for (int j = i + 1; j < n; j ++ )
        a[i][n] -= a[i][j] * a[j][n];
  

  return 0; // 有唯一解
  }

• 递推法求组合数 —— 模板题 AcWing 885. 求组合数 I

  // c[a][b] 表示从a个苹果中选b个的方案数
  for (int i = 0; i < N; i ++ )
    for (int j = 0; j <= i; j ++ )
        if (!j) c[i][j] = 1;
        else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

• 通过预处理逆元的方式求组合数 —— 模板题 AcWing 886. 求组合数 II
  首先预处理出所有阶乘取模的余数fact[N]，以及所有阶乘取模的逆元infact[N]
  如果取模的数是质数，可以用费马小定理求逆元

  int qmi(int a, int k, int p)    // 快速幂模板
  {
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
  }
  
  // 预处理阶乘的余数和阶乘逆元的余数
  fact[0] = infact[0] = 1;
  for (int i = 1; i < N; i ++ )
  {
    fact[i] = (LL)fact[i - 1] * i % mod;
    infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
  }

• Lucas定理 —— 模板题 AcWing 887. 求组合数 III
  若p是质数，则对于任意整数 1 <= m <= n，有：
  C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)

  int qmi(int a, int k, int p)  // 快速幂模板
  {
    int res = 1 % p;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
  }
  
  int C(int a, int b, int p)  // 通过定理求组合数C(a, b)
  {
    if (a < b) return 0;
  
    LL x = 1, y = 1;  // x是分子，y是分母
    for (int i = a, j = 1; j <= b; i --, j ++ )
    {
        x = (LL)x * i % p;
        y = (LL) y * j % p;
    }
    
    return x * (LL)qmi(y, p - 2, p) % p;
  }
  
  int lucas(LL a, LL b, int p)
  {
    if (a < p && b < p) return C(a, b, p);
    return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
  }

• 分解质因数法求组合数 —— 模板题 AcWing 888. 求组合数 IV
  当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
• 筛法求出范围内的所有质数
• 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中p的次数是 n / p + n / p^2 + n / p^3 + ...

• 用高精度乘法将所有质因子相乘

  int primes[N], cnt;     // 存储所有质数
  int sum[N];     // 存储每个质数的次数
  bool st[N];     // 存储每个数是否已被筛掉
  
  
  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;
        }
    }
  }
  
  
  int get(int n, int p)       // 求n！中的次数
  {
    int res = 0;
    while (n)
    {
        res += n / p;
        n /= p;
    }
    return res;
  }
  
  
  vector<int> mul(vector<int> a, int b)       // 高精度乘低精度模板
  {
    vector<int> c;
    int t = 0;
    for (int i = 0; i < a.size(); i ++ )
    {
        t += a[i] * b;
        c.push_back(t % 10);
        t /= 10;
    }
  
    while (t)
    {
        c.push_back(t % 10);
        t /= 10;
    }
    
    return c;
  }
  
  get_primes(a);  // 预处理范围内的所有质数
  
  for (int i = 0; i < cnt; i ++ )     // 求每个质因数的次数
  {
    int p = primes[i];
    sum[i] = get(a, p) - get(b, p) - get(a - b, p);
  }
  
  vector<int> res;
  res.push_back(1);
  
  for (int i = 0; i < cnt; i ++ )     // 用高精度乘法将所有质因子相乘
    for (int j = 0; j < sum[i]; j ++ )
        res = mul(res, primes[i]);

• 卡特兰数 —— 模板题 AcWing 889. 满足条件的01序列
  给定n个0和n个1，它们按照某种顺序排成长度为2n的序列，满足任意前缀中0的个数都不少于1的个数的序列的数量为： Cat(n) = C(2n, n) / (n + 1)
• NIM游戏 —— 模板题 AcWing 891. Nim游戏
  给定N堆物品，第i堆物品有Ai个。两名玩家轮流行动，每次可以任选一堆，取走任意多个物品，可把一堆取光，但不能不取。取走最后一件物品者获胜。两人都采取最优策略，问先手是否必胜。
  我们把这种游戏称为NIM博弈。把游戏过程中面临的状态称为局面。整局游戏第一个行动的称为先手，第二个行动的称为后手。若在某一局面下无论采取何种行动，都会输掉游戏，则称该局面必败。
  所谓采取最优策略是指，若在某一局面下存在某种行动，使得行动后对面面临必败局面，则优先采取该行动。同时，这样的局面被称为必胜。我们讨论的博弈问题一般都只考虑理想情况，即两人均无失误，都采取最优策略行动时游戏的结果。
  NIM博弈不存在平局，只有先手必胜和先手必败两种情况。
  定理： NIM博弈先手必胜，当且仅当 A1 ^ A2 ^ … ^ An != 0
• 公平组合游戏ICG
  若一个游戏满足：
  由两名玩家交替行动；
  在游戏进程的任意时刻，可以执行的合法行动与轮到哪名玩家无关；
  不能行动的玩家判负；
  则称该游戏为一个公平组合游戏。
  NIM博弈属于公平组合游戏，但城建的棋类游戏，比如围棋，就不是公平组合游戏。因为围棋交战双方分别只能落黑子和白子，胜负判定也比较复杂，不满足条件2和条件3。
• 有向图游戏
  给定一个有向无环图，图中有一个唯一的起点，在起点上放有一枚棋子。两名玩家交替地把这枚棋子沿有向边进行移动，每次可以移动一步，无法移动者判负。该游戏被称为有向图游戏。
  任何一个公平组合游戏都可以转化为有向图游戏。具体方法是，把每个局面看成图中的一个节点，并且从每个局面向沿着合法行动能够到达的下一个局面连有向边。
• Mex运算
  设S表示一个非负整数集合。定义mex(S)为求出不属于集合S的最小非负整数的运算，即：
  mex(S) = min{x}, x属于自然数，且x不属于S
• SG函数
  在有向图游戏中，对于每个节点x，设从x出发共有k条有向边，分别到达节点y1, y2, …, yk，定义SG(x)为x的后继节点y1, y2, …, yk 的SG函数值构成的集合再执行mex(S)运算的结果，即：
  SG(x) = mex({SG(y1), SG(y2), …, SG(yk)})
  特别地，整个有向图游戏G的SG函数值被定义为有向图游戏起点s的SG函数值，即SG(G) = SG(s)。
• 有向图游戏的和 —— 模板题 AcWing 893. 集合-Nim游戏
  设G1, G2, …, Gm 是m个有向图游戏。定义有向图游戏G，它的行动规则是任选某个有向图游戏Gi，并在Gi上行动一步。G被称为有向图游戏G1, G2, …, Gm的和。
  有向图游戏的和的SG函数值等于它包含的各个子游戏SG函数值的异或和，即：
  SG(G) = SG(G1) ^ SG(G2) ^ … ^ SG(Gm)
  定理
  有向图游戏的某个局面必胜，当且仅当该局面对应节点的SG函数值大于0。
  有向图游戏的某个局面必败，当且仅当该局面对应节点的SG函数值等于0。

计算从xx年xx月xx日 ------ xx年xx月xx日 一共经历了多少天
int end_year , end_month , end_day ;
int count_day(int year , int month , int day){

int ans = 0 ;
int mon[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
while(1){
    if(end_year==year && end_month == month && end_day == day){
        break ;
    }
    day++;
    if(isLeaf(year) && month==2){
        if(day>mon[month]+1){
            month++;
            day=1;
        }
    }else{
        if(day>mon[month]){
            month++;
            day=1;
        }
    }
    if(month>12){
        month=1;
        year++;
    }
    ans++;
}
return ans;

}

判断闰年
bool isLeaf(int x){

return (x % 400 == 0) || (x % 4 == 0 && x % 100 != 0) ;

}

欧拉筛选素数
const int N = 999999 ;
int vis[N] , prim[N] ;
int cnt = 0; // 素数的个数
for(int i = 2 ; i < N ; i ++){

if(vis[i] == 0) prim[cnt++] = i ;
for(int j = 0 ; j < cnt && prim[j] * i < N ; j ++ ) {
   vis[i * prim[j]] = 1 ;
    if(i % prim[j] == 0 ) 
       vis[i] = 1 ;
       break ;
}
 

}

好久没看自己的博客了，很惊讶他居然还能存在，最近是忙傻掉了

那就用来记录学医的过程中发疯日常以及学习c语言日常吧。
（可能会更新一些医学用语和话题，c语言也有，但不会很多）

{dotted startColor="#5d64e3" endColor="#f092eb"/}

成长不期而遇，愿以后的生活多一份幸运
#### 考入的大学，喜欢的专业，充实的兴趣，你和你的主持人，无一不是万喜万般皆相宜。
#### 你走过的路，你迈过的坎，在19年来，塑造了热烈而又勇敢的你。
#### 愿你成长，愿你落落大方，愿你不负众望。

{dotted startColor="#ff6c6c" endColor="#1989fa"/}

这里没有流星，但你可以许愿。

你的愿望将会被聆听，你的愿望会被记忆，你的愿望终将会在你的潜意识下实现。

或许你不知道考研考公之路的坎坷，或许你满脸的微笑，是你对自己的认可，对自己的肯定，这必将会慢慢改变你的大学生活，感谢你这些年来所遇到的美好奇遇。

{dotted startColor="#ff6c6c" endColor="#1989fa"/}

中秋佳节，皓月当空

皓月当空撒清辉，中秋良宵念挚心。

学习虽苦，外面的生活虽丰富，但你的父母才是最爱你的，多陪陪父母，家中也要常来信。

{dotted startColor="#ff6c6c" endColor="#1989fa"/}

你的19，与众不同。

生活明朗，万物可爱，你要按时长大。

但逢良辰，顺颂时宜，万事顺遂！

愿你更加开朗，更加活泼，在属于自己的舞台发光发热！

{dotted startColor="#ff6c6c" endColor="#1989fa"/}

话不多说，最后 吾祝你前程似锦，一路芳华 。任何时刻都要保持开森明朗

————————因为我重度抑郁真的难受

笔者一直以为，好的作文语言应该是饱含诗情、富于哲理的，哲理与诗情的完美融合，是我们作文语言的终极追求。对于语言的诗意，笔者曾在《语不惊人死不休——作文语言陌生化艺术探索》里发表过自己的一些看法，认为诗意的语言主要是通过陌生化手法实现的，也就是运用语言陌生化艺术，可以使得作文语言诗意盎然。本文将要阐述的，就是如何使得作文语言富于哲理，充满思辨。
一、哲理的哲学原理及其与思辨的关系
“哲理”一词我们并不陌生，甚至非常熟悉，望文生义就是哲学道理，究其本义其实是指宇宙和人生的原理。这是我们大都知道的，但叫我们具体说出哲理是什么或是怎样才叫做有哲理甚或如何做到有哲理，却并不是一件容易的事。哲理是一种通俗化的哲学，各种各样、各门各派的高深哲学都可以简化为一种或多种哲理。哲理就是一种道理，它并不玄奥，也不必成为一个庞大的体系；但哲理的获取却往往依赖于哲学的方法、哲学的原理。
哲学源自于对事物的诧异，也就是说哲学的产生、嬗变都是因为哲学家对事物的好奇、热心和怀疑。哲理也是，我们对正在陈述的对象毫无诧异之感、好奇之心，我们的叙述肯定是平铺直叙的，是不可能让语言哲理化的。对我们正在陈述的事物保持好奇、怀疑之心，这是语言哲理化产生的心理基础。
哲学的基本方法就是思辨，说得直接点就是辩证法。古往今来，哲学种类繁多，哲学门派林立，虽然他们的思想体系纷繁复杂，甚至思想观点相互抵牾，但他们都用同一种方法进行他们的哲学思考，那就是思辨。这种思辨一般都遵循几条途径，或说是几个维度。一是横向的遵循事物之间的全面联系关系，二是纵向的遵循事物的发展变化的规律，一是把同一事物从正反对比的角度一分为二或合二为一。哲理也是如此，它的方法也是思辨，即辩证地思考。思辨的结果就是语言具有哲理性，全面、准确、深入，给人启迪，令人信服。
哲学是研究自然、社会和思维的最一般规律的科学，概言之，它的基本对象就是宇宙和人生，而这恰好也是哲理思辨的对象。宇宙很大，宇宙很广，它包罗万象，我们一般人是没有太多必要，也没有太多能力去对宇宙进行研究。我们主要关心人事，也就是宇宙之下、社会之上的人和事，说简单点就是人生。我们时常对我们的人生怀有惊异之心，定有惊异之发现；我们对我们的人生从全面的、发展的、辩证的维度去观照，定然会感受到人生的深刻之处，进而发现人生的哲理。我们再给这些哲理穿上语言的外衣，这些哲理就会给别人以启迪。
二、语言哲理化的途径与方法
诚如上文所言，哲理的方法就是哲学的方法。语言哲理化的途径与方法就是时时对人生怀有惊异之心，并用全面联系、发展变化、一分为二等方法对这种诧异进行思辨，最后外化为语言。我们先来看几个来自苏教版高中教材例子。
“在‘两代的矛盾中’可能有一部分是源于父母的愚昧和落伍，但也有一部分是出自下一代对父母经验的无条件否定，出自年轻人的盲目反抗与追求‘成熟’‘独立’的急躁。”（《十八岁和其他》）正是由于杨子对两代人之间所谓的矛盾保持好奇探究之心，才促使它思考这其中的道理，而“一部分是源于父母的愚昧和落伍” “一部分是出自下一代对父母经验的无条件否定”则体现了他全面而辩证的思维，带有一定的哲理性。
“我怀着希望播种，那希望决不比任何一个智者的希望更谦卑。”（《我的四季》）张洁心怀希望，春天播种秋天一定会有收获的希望，事物的发展轨迹不可辩驳；她还把希望一分为二，即“我的希望”和“智者的希望”，并进行的比较，语气斩金截铁，辩证的力量令人信服。
这就是语言哲理化的基本途径与方法，任何哲理化的语言都留有这种方法的痕迹，它为我们语言哲理化指明了方向。但正因为是最基本的、最一般的，所以具体操作性不强。我们需要在这一方针指引下，寻找切实可行的作文语言哲理化的方法技巧。
1.坚决果敢的语气，毫无例外的范围，表达一种无可辩驳的哲理。
我们试看《我的四季》里的两个例子。
“我绝不企望有谁来代替，因为在这个世界上，每个人都有一块必得由他自己来耕种的土地。”“我怀着希望播种，那希望决不比任何一个智者的希望更谦卑。”“绝不”“必得”语气毅然决然，坚定果敢，毫无商量；“世界上”、“每个人”涵盖一切，无一例外。这就传达出一种“必须如此”“概莫例外”的哲理的力量，令人毫不怀疑。
这类例子还有：“再没有可能纠正已经成为往事的过错。一个生命不可能再有一个四季。未来的四季将属于另一个新的生命。”（《我的四季》）“我们的体质常常威胁我们，可是任何人也不敢藐视它的权利。”（《青年在选择职业时的考虑》）等等。
2.文意的正向推进，意脉的步步高升，表达出一种必然如此发展的哲理。
这里一般会运用一些关联词。我们来看两个例子。
“人要是能够期待，就能够奋力以赴。”（《我的四季》）“要是”就是“只要是”，句子其实利用了“只要……就……”的关联，表达出一种只要条件具备，就一定会达致某种结果必然性哲理。
“我们先得向杰作表明自己的价值，才会发现杰作的真正价值。”（《获得教养的途径》）“先得”就是“只有”，句子也是利用了“只有……才……”的关联，向我们展示了一种辩证的逻辑：发现不了自己的价值，就发现不了杰作的价值。
诸如此类句子，教材里也是屡见不鲜：“伟大的东西是光辉的，光辉则引起虚荣心，而虚荣心容易给人以鼓舞或者一种我们觉得是鼓舞的东西。”（《青年在选择职业时的考虑》）“只有从安静中才能产生出伟大壮丽的事业，安静是唯一生长出成熟果实的土壤。”（《青年在选择职业时的考虑》）
3.文意的反向推进，前后形成对比转折，表达出一种非此即彼的辩证哲理。
前例《十八岁和其他》：“在‘两代的矛盾中’可能有一部分是源于父母的愚昧和落伍，但也有一部分是出自下一代对父母经验的无条件否定，出自年轻人的盲目反抗与追求‘成熟’‘独立’的急躁。”就属此类。我们再来看看下面两句话。
“如果一个人只为自己劳动，他也许能够成为著名学者、大哲人、卓越是人，然而他永远不能成为完美无瑕的伟大人物。”（《青年在选择职业时的考虑》）“然而”表示转折，前后在文意上形成对比，如果你想成为前者，只为自己劳动或许就可以了；而你要成为后者，则必须还得很好的为他人劳动。
“一个人，出生了，这就不再是一个可以辩论的问题，而只是上帝交给他的一个事实。”（《我与地坛》）“不再是”“而是”，就是一个非此即彼的辨证选择，所选择的一般都是后者，对比之下，突出后者的重要性。
4.利用“是”“不是”的肯定或否定判断，表达出一种对性质的界定性的哲理。
举两个例子。
“尊严就是最能使人高尚起来、使他的活动和他的一切努力具有崇高品质的东西，就是使他无可非议、受到众人钦佩并高出于众人之上的东西。”（《青年在选择职业时的考虑》）“尊严就是……东西”实际上是一个定义，定义的本义就是揭示被定义对象的本质特征，这就是一种定性的哲理。
“所以死是一件不必急于求成的事，死是一个必然会降临的节日。”（《我与地坛》）“死是……事”“死是……节日”，也符合“是”“非”的判断特点，判断本身就是一种智慧，一种哲理。
我们还可以举出很多例子，如：“死亡原来也是一件充满庄严和尊严的事情。”（《西地平线上》）“放弃就意味着彻底的割舍。”（《我的五样》）等等不一而足。
5.两面情形相互对照，形成一种对比突出、优劣自明的选择性哲理。
比如下句：
“为别人对你的好感、承认、报偿做的事，如果别人不承认，便等于零。为自己的良心、才能、生命做的事，即便没有一个人承认，也丝毫无损。”（《每个人都是一个宇宙》）“为别人”“为自己”就是两相对照，“好感、承认、报偿”“良心、才能、生命”是对照，“等于零”“丝毫无损”也是对照。怎样做事是一种生活态度，对比之下，我们该采取哪一种，是不言而喻的。
又如下句：
“有两种哲学家。一种人把哲学当做他的职业，即谋生的手段。另一种人把哲学当做他的生命甚至是比生命更宝贵的东西。”（《未经审察的人生没有价值》）“一种人”“另一种人”是对照，“当做职业”“当做生命”也是对照，谁是真正的哲学家，也就十分清楚了。
再如下句：
“爱和孤独是人生最美丽的两支曲子，两者缺一不可。无爱的心灵不会孤独，未曾体味过孤独的人也不可能懂得爱。”（《爱与孤独》）“爱”“无爱”是对照，“孤独”“不会孤独”也是对照，相比之下，只有真正的“爱”和真正的“孤独”才会在我们的人生里和谐共生。
其实，很多饱含哲理的话不一定就要使用某种方法。像“在满园弥漫的沉静光芒中，一个人更容易看到时间，并看见自己的身影。”（《我与地坛》）就很有哲理，但我们似乎不需要为它归纳什么方法了。换句话说，当哲理思考已经成为已经成为一种习惯，所谓哲理化的方法和技巧就显得可有可无了。
三、经典哲理化句子选读
理论是灰色的，生命之树长青。下面列述一些饱含哲理的经典语句，供揣摩学习。
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.人把自身当作现有的.有生命的类来对待，因为人把自身当作普遍的因而也是自由的存在物来对待。——马克思，选自《1844年经济学哲学手稿》
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.历史是由活着的人和为了活着的人而重建的死者的生活。——雷蒙·阿隆，选自《历史讲演录》

容颜如玉，身姿如松，翩若惊鸿，宛若游龙。
他让我想起一句话，
命运对勇士低语：你无法抵御风暴。
勇士低声回应：我就是风暴！
羽生结弦，一位不待扬鞭自奋蹄的选手。

今天夜雨为大家整理一期日本花滑选手及素材运用示例 ——羽生结弦
千呼万唤之下，终于，在昨天下午，我们等来了羽生结弦抵达北京的消息。 相信对于关注冬奥的人来说，羽生结弦，都不是一个陌生的名字，甚至不仅仅只是一个名字，更是一种精神，一种对梦想的执着。
很难想象央视会如此赞美一个日本运动员吧，但是羽生结弦确实是一个非常优秀的花滑选手，也因为他值得。
有人说我不喜欢日本，但我喜欢日本的羽生结弦。为什么这样说呢？因为有这样一幕——在2017年花样世锦赛颁奖礼上，他看到金博洋的国旗拿反了，于是主动上前帮忙整理。就是因为这样，他尊重中国，我们就尊重他，喜欢他。
他曾说过，我的目标是奥运冠军。为了实现自己的目标，他一路披荆斩棘，终于在东奥二度夺冠，打破了19次世界纪录。
但羽生结弦从小就体弱多病，患有严重的哮喘。在他17岁时，比赛中途哮喘发作，但他却坚持完成了4分半的表演，结束后瘫在了地上，却又坚强的站了起来，谢幕，后颤颤巍巍的走出了赛场。 哮喘让他的运动员生涯充满坎坷。但他却因为哮喘付出了比别人多倍的努力。他曾这样说过：“无论有多疼，就算之后脚踝不能动了，我也要拿下金牌。我有这样的使命感和意志。”他尽乎苛刻要求自己，也曾为高难度的跳跃，他几乎拼上性命。面对运动员生涯，他一直都带着破釜沉舟的决心。羽生结弦那股拼尽全力的热血劲儿和拼上性命的努力，或许就是他连胜的秘诀吧。
我们很少见运动员在赛场上哭泣。但我们却多次看到了羽生结弦夺冠后的眼泪。我想那不是因为训练的疼，而是喜极而泣。
我们不能用天才这一词来形容他，因为他在背后付出了很大的努力。我们不知道他有多累，有多疼。但我们看到的是面对咄咄逼人的镜头下的他不能哭，面对社会的胡乱诋毁不能哭。
他在热身时与一位选手高速相撞，鲜血直流，但他只经过简单的处理就要上场，观众高声阻拦，可他却怒吼“跳”。冰上那位绑着绷带的翩翩少年，奋力的舞着，像是一朵在冰面上带着雪燃烧着生命盛开的樱花。他在冰面上谱写着一场让无数人泪目的血色魅影。最终以获得亚军得来了观众的掌声。就是因为有这样的坚持精神才会成就现在的他。
2014年，中国花滑选手闫涵和羽生结弦在赛场热身时相撞，俩人双双倒地，因为疼痛，身体蜷缩在一起，等闫涵站起后，羽生结弦也没有站起来，最后在教练的帮助下起立，此时，血已经顺着流到了脖子里，简单处理过后，在众人的反对声中完成接下来的比赛，8次起跳，5次摔倒，但每次都用尽全力站了起来，也由此，收获一名银牌。 赛后诊断显示，碰撞造成严重腹部损伤 央视解说员陈滢曾经在一次比赛中这样评价羽生结弦：“容颜如玉，身姿如松，翩若惊鸿，婉若游龙”
身姿轻盈，加上极强的柔韧性一度让观众认为羽生结弦的滑行过于阴柔，不仅挑战男子的超高难度动作，还很轻易就完成贝尔曼旋转。但不曾想，就是这样的羽生结弦已经19次打破世界记录，是ISU认可的国际比赛中完成后外结环四周跳的第一人，而在今年的北京冬奥会上，他还将挑战4A（Axel / 阿克塞尔四周跳），这是目前动作表上唯一一个向前起跳的跳跃，4A是一个四周半跳，是一个超越人体极限的动作，为了这一刻，他跳了八年，也许正是这次执念才支撑羽生结弦走到了今天。
A是花样滑冰中跳跃的一种。前边的数字，是指跳跃的周数，后边的字母，是指跳跃的种类。
花样滑冰的跳跃种类一共有六种，从易到难依次是：
后外点冰跳（Toeloop，简称T）；向后滑行时起跳。
后内结环跳（Salchow，简称S）；向后滑行时起跳。
后外结环跳（Loop，简称Lo）；向后滑行时起跳。
后内点冰跳（Flip，简称F）；向后滑行时起跳。
勾手跳（Lutz，简称Lz）；向后滑行时起跳。
阿克塞尔跳（Axel，简称A），向前滑行时起跳。
在一次采访中，羽生结弦说道：“既然参加了，我就要稳稳获胜。跳出真正的四周半跳”

对于我们来说可能只会记得获得冠军的他，却不知他背后的经历的磨难。28岁的他成为了无数人的目标。
放下国家情怀，他是值得热爱的一个人带上国家情怀，我们依旧要尊重他，他是优秀的，与国家无关。
“幸得识卿桃花面，从此阡陌多暖春”，“时光作渡，眉目成书”，“容颜如玉，身姿如松。天若惊鸿，宛如游龙。”央妈这样赞美他，当你面对梦想路上的荆棘时，当你畏惧，当你想要放弃的时候，羽生结弦的励志故事将给予你方向与力量，希望羽生结弦能在本次冬奥会上圆梦，为所有运动健儿们加油！
我愿称之他为“羽生·花样使者·哮喘征服者·被冰选中的人·结弦”。

1.羽生结弦挑战4A
北京冬奥会上，如无意外，羽生结弦将挑战4A。这个动作被认为是超越人体极限的动作，之前在花滑历史中还从未有人攻克过。
适用主题：超越极限，挑战自我
运用示例：作为花滑选手，羽生结弦已经斩获两枚冬奥金牌，如果能够在北京冬奥会上夺冠，就可以创造史无前例的“三连冠”。然而，他并不满足于此，他想超越极限，超越自我，向4A发起挑战。4A指的是Axel（阿克塞尔）四周跳，是超越人体极限的动作，在花滑的历史中还从未有人攻克过。然而，这样的一个高难度动作，评分上并不占太大优势，一旦失手，则会有较大影响。因此，一般选手都不会在冬奥会上轻易尝试。然而，羽生结弦则义无反顾。让我们期待这位冰王子创造新的奇迹！

2.羽生结弦曾带伤上阵
2014年，世界花滑中国大奖赛上海站现场，羽生结弦在赛前热身时，与中国选手闫涵意外相撞。因为伤势较重，教练和医护人员均劝其放弃比赛，但羽生结弦坚持比赛。比赛中，受伤势影响，他8次起跳，5次摔倒，但依然咬牙坚持，最终获得了银牌。
适用主题：遭遇意外，不惧挑战，克服困难
运用示例：人生路上，常常会有不期而遇的风雨。遭遇意外时，我们应该像羽生结弦一样，咬牙坚持。2014年，世界花滑中国大奖赛上海站现场，羽生结弦在赛前热身时，与其他选手意外相撞。因为伤势较重，身边人劝其放弃比赛，但羽生结弦坚持带伤上阵。比赛中，虽然屡屡摔倒，但他依然坚持完成全套动作。最终，他用自己的坚韧，战胜了意外，夺得了银牌，也让现场观众起立鼓掌。
3.羽生结弦的偶像魅力
干净俊秀的外貌为羽生结弦加分不少，但真正让他获得认可的，还是顶尖实力。羽生结弦年纪轻轻多次刷新世界纪录，拥有绝美的舞台表现力，索契冬奥会《巴黎散步道》和平昌冬奥会上《阴阳师》的完美表演成为了很多人的“入坑作”。
适用主题：实力，魅力，偶像
运用示例：真正的偶像，都拥有过硬的实力。羽生结弦被公认为超级偶像。不可否认，干净俊秀的外貌为羽生结弦加分不少，然而，真正让他获得认可的，还是顶尖实力。在冰面上，他翩若惊鸿，婉若游龙，拥有绝美的舞台表现力。平昌冬奥会和索契冬奥会上的“两连冠”，就是绝对实力的最好展现。正是有了这种绝对实力，才让粉丝放弃“抵抗”，彻底“入坑”。
4.羽生结弦对中国人非常友好
羽生结弦对中国人非常友好。有记者曾经问他：你喜欢中国吗？他肯定地回答：是的，我爱中国。他还曾主动帮中国花滑选手金博洋整理国旗，这一举动也打动了在场的中国观众。
适用主题：友好，团结，优质偶像
运用示例：众所周知，羽生结弦是日本花滑运动员，因为历史原因，中日两国充满芥蒂，中国人一向不太待见日本运动员，然而羽生结弦是例外。他在中国拥有超高的人气，还没有来北京参加冬奥会，就多次冲上中国微博热搜，由此可见人气之高。究其原因，在于他不仅实力超群，而且谦逊友好。他曾主动帮中国花滑选手金博洋整理国旗，这一举动，打动了中国观众，甚至有喜欢他的中国网友调侃“终究是爱上了世仇家的儿子”。
5、“紧紧追逐着顶点”
羽生结弦，1994年12月7日出生于日本宫城果仙台市，从四岁起开始学习滑冰。十二岁时，他已经定下成为奥运会冠军的目标。多年的坚持与努力，让19岁的羽生结弦成功在2014年索契冬奥会中摘得花样滑冰男子单人滑项目的金牌。赛后，他固然是喜悦的，但也为在比賽中出现失误而懊恼:“有种没能把自已的实力完完全全在大舞台上发挥出来的不甘,像是输给了自己。”
为了能在四年后的平昌冬奥会上没有遗憾，羽生结弦继续着他对顶点的追逐，“一直将目标定在自己能做到的最大限度”。为此，他修习了人类工程学课程一一因为他觉得花样滑冰与人类工程学有相通之处，可以用公式来表达动作，如“力是如何施加的，力的作用在哪里、会有怎样的冲击”，“希望能运用到花样滑冰中”。为了让竞技表演更有艺术感，羽生结弦自己编辑表演音乐，使自已的每个动作乃至每个呼吸都和音乐合拍。正是这些平日里的刻苦付出，羽生结弦的花滑水平才会日益精进，在赛场上即使出现失误也能迅速调整。在平昌冬奥会自由滑的比赛中，羽生结弦一度出现失误。在这紧急一刻，他凭借强大的心理素质和丰富经验，“果断决定调整难度”， 最后才成功摘得平昌冬奥会花样滑冰男子单人滑桂冠。
适用主题：追求梦想，踏实前进
运用示例：当定下成为奥运冠军这个非常宏大的目标后，羽生结弦并没有让它成为一句空话。相反，他朝着这座竞技高峰踏实前进，一步一个脚印。从小学起，羽生结弦就坚持做花滑笔记，认真观察并记下自已身体的起伏，为了更好地精进滑冰技术，他还将大学专业与花样滑冰相联系，从理论方面进一步提升。若想摘星,须得一步步搭建起通天的桥梁，稳稳地脚踏实地、拾阶而上。正是这些扎实的训练与努力让羽生结弦在平昌冬奥会成功卫冕。
6、不惧伤痛，一往无前
在追逐梦想的路上，羽生结弦并非一帆风顺。挫折与磨难常常不期而至，但这些都没有阻挡他前进的脚步。
2014年，羽生结弦在索契奥运会的自由滑环节中出现失误——摔倒在冰面 上。这导致部分媒体指责他不能以完美姿态登顶，并且嘲讽他为“摔跤冠军”。2017年11月,羽生结弦右脚踝受伤，很长一段时间都不能站上冰面。
这些身体的伤痛让羽生结弦感到焦虑，但他并没有因此放弃，他将这份“输给了自己”的不甘转化为“紧紧追逐着顶点”的动力。羽生结弦曾直言:“我不讨厌逆境，超讨厌弱小的自己，可是，弱小就意味着有变强的可能性。”
为了能更深入地了解自己的受伤情况，羽生结弦进行了解剖学的学习;在无法上冰的情况下，羽生结弦坚持看着录像做意象训练。他还在奥运会前自信地对媒体表达自己想要蝉联奥运会冠军的强烈心情，从而让自己保持“精神面的控制”。
适用主题：克服困难，坚持，执着追求
运用示例：“要紧紧追逐着顶点，努力拼搏”的信念是羽生结弦始终不变的初心。羽生结弦的王者之路并非只有鲜花与掌声，它也密布着刺人的荆棘。在花样滑冰的路上，羽生结弦遭受了大大小小的伤病，承受了许多来自外界的言语中伤。但这些挫折与困难都没有让他退缩与放弃。他选择相信自己，不断努力，也正是这份执着让他从蹒跚幼童一步步成长为蝉联冬奥会花样滑冰冠军的冰上王者。

赞美冬奥会上羽生结弦的表现，可以用这些句子

1.日月星辰，只是陪衬。
适用主题：惊艳（感），无与伦比
示范：像是漫画里的少年，你优雅的身姿，倒映在冰面。身上的白衣，在滑行中蹁跹，仿佛白鸽飞翔在蓝色的海面。你腾空旋转，稳稳落地，优美的舞姿炫酷又惊艳。那一刻，仿佛时光停止了流淌，又仿佛全世界的目光都为你流连，日月星辰，只是陪衬。

2.冰上人如玉，公子世无双。
适用主题：惊艳（感），少年（感）
示范：“冰上人如玉，公子世无双。”你在最寒冷的冰场，绽放最炙热的光芒；也在最孤独的舞台，映照万千目光。你是冰上的阴阳师，是热血动漫里的主角。你是爱，是暖，是希望，是人间的四月天，是白色战场上唯一的王！

3.跳跃的精灵，舞动的王子。
适用主题：实力，偶像
示范：长着少女漫画主角的脸，活得却更像一部热血动画，这样的羽生结弦，成为了无数人心目中的超级偶像。生活中，他安安静静，可当他站在冰场上，他就成为了跳跃的精灵，舞动的王子。这样的反差萌，让人更加喜爱。

4.幸得识卿桃花面，从此阡陌多暖春。
适用主题：惊艳（感），温暖
示范：幸得识卿桃花面，从此阡陌多暖春。这是我们遇见羽生结弦的直观感受。岁月无声，悄然流逝。每一个人的青春都会老去，但是我们的记忆里，永远会为羽生结弦留一个位置。

5.除却君身三重雪，天下谁人配白衣。
适用主题：少年（感），惊艳（感）
示范：像是传说中的天使一般，你穿着白衣，降临在眼前。那么耀眼，全场的目光都被你吸引。你在冰面上踩着音乐节拍，蹁跹起舞，白衣飘飞，像鸽子飞翔在蓝色的海面。从此，我记住了你的名字，也一直认定——除却君身三重雪，天下谁人配白衣。

6.容颜如玉，身姿如松，翩若惊鸿，婉若游龙。
适用主题：魅力，风范
示范：2018年2月，平昌冬奥会，羽生结弦获得男子单人滑冠军，成为66年来第一位蝉联冬奥会男单冠军的花滑选手。对于这场比赛，央视解说员陈滢老师无比激动，称赞羽生结弦“容颜如玉，身姿如松，翩若惊鸿，婉若游龙。”

7.你生而创造历史，而我何其有幸，见证历史。
适用主题：创造历史，见证历史
示范：你是冰上的王子，一次次随着音乐的节奏，翩跹起舞。从索契到平昌，再到北京，你一次次以优雅的舞姿，让全场惊艳。你长着少女漫画主角的脸，活得却更像一部热血动画。你生而创造历史，而我何其有幸，见证历史。

42句羽生结弦的励志语录

花滑运动员羽生结弦为什么会火出圈？我想，大概就是他不仅活出了自己的样子，也活成了很多人心目中自己的样子。
有人喜欢他的可爱帅气，有人喜欢他正直友善，而我喜欢他的励志正能量，从不为自己的失败找理由，确确实实地活成了他自己的样子。
羽生结弦并不是一鸣惊人的一举夺冠，但的确是一战扬名。
下面让我们来阅读一下42句羽生结弦的励志语录吧！

01.十代结弦，一生悬命。
02.绝对赢给你看。
03.向理想的前方迈进。
04.目标应该是变化的。
05.曾经有许多艰辛之事，但没有不拂晓的夜晚。
06.自己的极限，理想的前方。
07.我也想要获得压倒性的胜利！
08.如果以疼痛作为借口我就输了。
09.拼尽全力就是鼓起勇气的方式。
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.真正强大的人不论周围是怎样的环境，都可以不顾及地表现出自己，没有办法做到的话大概是因为软弱。

链接阅读：
就算羽生结弦此次没有成功完成4A，我们也无法抹去他曾创造的辉煌，正如央视解说的那样：他没有对手，如果非要说有，那也只有他自己。

1
-

努力是他真正天才的地方
羽生结弦1994年12月出生在日本仙台的一个普通家庭。父亲是中学的教导主任，母亲是全职家庭主妇。
名字结弦，是爸爸起的，一是呼应他的星座射手座，另外就是希望他的人生想弓弦一样张弛有度。
羽生从小患有哮喘，4岁的时候家人抱着强身健体的心态让他去和姐姐一起学习滑冰。妈妈觉得，溜冰场是最不容易吸入灰尘的运动场地。

本来是抱着锻炼的心态去的，教练却很快发现羽生身体素质和柔韧性都非常好。最重要的是，无论摔倒多少次这个坚强的小孩都会重新站起来。“姐姐能做到的，我也可以”，从那时起，内心的强大以及不服输的精神，就展露出来了。
9岁那年，小学四年级，羽生参加全国比赛，一举获得了冠军。
11岁时，他留着和偶像俄罗斯的传奇选手普鲁申科一样的蘑菇发型，他羞涩而笃定的说：“我的目标是拿到奥运会金牌”。
15岁，他成为了青年组的世界王者，一路过关斩将，成为日本最年少的世界青年锦标赛的男单冠军。
然而，羽生接下来要迎接更严峻的挑战，进入成人组。虽然身怀其他男选手很难完成、强调高柔韧性的“绝招”，但大人们也有自己的“杀手锏”——强调综合性的四周跳。这是花式滑冰里最难的一个动作，也是参加奥运会的技术门槛。
这是网上找到的一段专业解释，四周跳1440度后，落冰时脚要承受5-7倍的自身质量！
在四周跳时，人类需要违抗生存本能。在空中身体的转速达到每分钟400转，并始终要控制好身体，而一辆开到100公里/小时的车轮转速，也不过每分钟800转……
为了早日练成四周跳，15岁的小伙开始了“自杀式训练”。一般选手每天练20到30次四周跳已是极限，但羽生一天会跳60次！每分钟一次的练习，五十次，才只能成功一次。
对我们来讲，多练30次或许只是一个数字的概念，对实际训练者，却承受着无比的压力与痛苦。

有网友做了这样的计算：
一次四周跳就意味着选手要在0.7秒的滞空时间内，让身体旋转四周。
由于身体高速旋转，人在落地时候受到的冲击力至少是体重的5倍。
羽生结弦百科上的体重是57kg，你可以算算他每天跳60次要承受多少冲击力？
我用最简单的方法算57kg×5×60=17吨！
靠着这样日复一日的摔打与伤痛的不懈努力，3个月后，他做到了。
这个时期的教练阿部奈奈美，见证了羽生四周跳的起步与成功，她是这样评价羽生的：
“是的，我认为羽生结弦是天才。
但他的天才和别人所说的天才有点不一样。
他可以比别人付出多一倍的努力，他可以为了将本身天赋最大限度地发挥出来而努力。
这种努力的方式，正式我觉得他真正天才的地方。”
羽生结弦语录：“努力会说谎，但努力不会白费。”

2
-

只要还能爬，就不会放弃
2014年的“花滑中国杯”上，有段羽生迷们至今不忍回忆的历史，很多人也是在那时入了羽生的坑。
在赛前6分钟练习时，羽生与中国选手闫涵在毫无防备的情况下剧烈相撞，他头部、下颚、腹部、腿都受了伤，昏倒在地长达两分钟，颈部也被割伤流血不止。高速的强烈撞击令他痛得躺在冰上喘息。
下巴和额角在不能麻醉的情况下缝了几针，贴上止血绷带，头部做了简单包扎后羽生又回到了赛场，仅仅试跳一下就开始气喘不止。他转身抹去泪水。
教练叮嘱他：“你的健康才是最重要的。”
但羽生咬咬牙，他眼神坚定破釜沉舟：“跳！”
重返冰场的过程中，他冷静地修改动作构成，把由于受伤而可能完不成的动作重新组合，他默默计算着分数。预料之中，节目中八个跳跃他摔倒了五次！
倒下站起倒下站起倒下站起！
表演完成后，观众仍然为他撒下漫天的维尼熊雨，羽生硬撑着与观众鞠躬作别，踉跄着回到台下。
羽生喜欢维尼熊，每次比赛观众都会为他准备维尼熊
胜利必然属于这样强悍的战士，羽生的拼死坚持成就了“血色魅影”的悲壮，最终拿了银牌。
对他来说，在赛场上，只要能爬起来，就绝对不会说放弃。
他描述自己的花滑生涯，三个形容词之一是：一生悬命，应该是最好的诠释了吧。
我全程观看了这段比赛录像，一个20岁的男孩的行动，几次触动了我的痛点。
一个镜头是急救包扎后，他不忘与他相撞同样受伤的闫涵，脸色沉重了询问了好几句闫涵，闫涵呢？并亲自去找了闫涵。
第二个镜头，下场后，羽生几近虚脱，脸上满是汗珠，但在与教练交流的过程中还试图保持微笑，虽然那笑容已被痛苦折磨的变了形！坚强如他，受伤时倔强的微笑，在公布结果的那刻，羽生忍不住哭成泪人，让人心疼。
是的，就是这样，从不服输，从不放弃。有多少次他就是这样突出重围，绝地绽放。
正如2011年的3月11日，羽生的家乡仙台经历了世界末日般的9.0级大地震。家、学校和冰场全部被毁，羽生全家人住进了临时避难所，每天只能领到两个饭团勉强充饥。
失去了训练场地，羽生的妈妈四处奔走，向滑冰协会甚至是向教练多次求情疏通。妈妈的坚强同样传递给了羽生。
从未想过放弃的羽生，半年的时间里跑遍全国各地，参加了几十场商业演出，为的是用商演的冰场进行训练。正是在这段时间里，他完成了后来艳惊四座的《罗密欧与朱丽叶》的排演。
2018年平昌奥运会之前，羽生右脚受伤，严重到整整停赛了3个月，直到冬奥会赛前一个月才恢复训练。颁奖礼上，羽生几乎是单脚跳上领奖台的。
媒体问羽生类似这样的问题：
“怎样看待受伤的那段时间，自己是怎么在如此短的时间内调整过来的？”
羽生回答：
“如果没有发生受伤的事情，或许我就拿不到奥运冠军了，因为受伤，才有机会思考，有机会学习其它内容，这次的经历让自己以后面对其它困难时再也不会这么艰难，多亏了这次受伤，三个月不能上冰切实成为了我的力量。”
面对逆境，有人选择抱怨，有人选择萎靡，而羽生选择了奋起，选择了感激，他用“多亏了”来形容那场受伤。
央视解说陈滢说:
“他的每一个动作，每一场比赛，都是带着全力以赴的心态去比。他在2014中国杯上，赛前重伤的情况下，8个跳跃摔了5个依然爬起来继续完成动作。那场赛事让所有关注花滑的观众对羽生那种坚毅不屈，那种顽强印象深刻。结束前他的造型让我想起了樱花。樱花绽放之前就要抱着凋零的决心。”
羽生结弦语录：曾经有许多艰辛之事，但没有不拂晓的夜晚。

3
-

我要变得更强
羽生结弦说过，他觉得运动员是没有极限的。
“如果不逼自己，不挑战自己，就丢了作为运动员的初心。”
他不停刷新世界纪录，书写着羽生如何挑战自己极限的传奇，拔高了世界花滑界的水平，一次又一次刷新了人们对于花样滑冰难度的认知。
他是首次在比赛中尝试多次数、不同类型四周跳的第一人。从他开始，运动员才开始意识到花滑还有更多提高和突破的可能，诸如花滑运动员陈巍、宇野昌磨、金博洋均是在他之后开始尝试完成高难度的4Lo（四周鲁卜跳）、4F（四周菲力甫跳）、4Lz（四周路兹跳）等花滑技巧。
他是一个已经站在世界之巅还不断挑战自己的王者。别人是把奥运冠军当做终点，而他把奥运冠军当做起点。毕竟在这个世界上，人最大的对手就是自己。
羽生从小学开始记滑冰笔记，每场比赛，每次练习，他都会记下来，记了一本又一本。
笔记本扉页上写着四个大字——“绝对要赢”，本子上全是他对自己的深度剖析，详细的比赛心得，记载着羽生努力拼搏的每一个足迹。
如果你认为他只是个滑冰运动员，那么你就错了。羽生结弦还是个十足的学霸，他一边潜心训练，一边苦心读书，以正规考生的身份货真价实地考上了日本名校早稻田大学，与索尼创始人、三星创始人、优衣库创始人以及村上春树等大佬成为校友。
他的专业是人类情报科学。读这门课，是因为他想从更多元化的角度了解人体，从科学的角度分析身体的跳跃、动作要用什么角度、多大的力量、速度最合理。他还把人体工学的知识融入到了花滑动作的设计中。
花滑是技术与艺术结合的美丽运动。为了增强艺术感染力，羽生还利用业余时间学习了编曲。重新编排比赛的曲子，仔细思考每一个节奏安排哪个动作最和谐，把跳跃、步法都融到音乐里，让人感觉到浑然天成；他还在音乐开头放进自己的呼吸声，让自己开始前调整呼吸，放松之余还能够让自己的实力最大化。
每当音乐响起，羽生便带着他所有对于花滑的梦想优雅滑行，将观众带入绝美的观赏境地，达到技术与艺术的完美平衡。
羽生结弦语录：奥运冠军什么的、世界冠军什么的，都没有关系。我丝毫没有失去动力，我还想要变的更强大。新的敌人就是我自己。

日本花滑选手羽生结弦在2018年的奥运辉煌，已经过去四年。2022年羽生结弦可否再创记录，我们都在期待中！

{music-list id="6806401943" color="#1989fa" /}

.

2022 7 9 初次认识xxz（小学生）

{card-describe title="长这样"}

{/card-describe}
后来.......

{timeline}
{timeline-item color="#19be6b"}
在星空沙漠到处飞,聊天......

{/timeline-item}
{timeline-item color="#ed4014"}
俩无翼到处跑图
{/timeline-item}
{/timeline}

{lamp/}

再后来.......

{mtitle title="后来她问我数字作业"/}
我给她看了五三的题目，她说看得懂一半，啊哈哈哈哈哈哈哈哈哈