导论

1. 市场和市场营销定义

   从市场营销的角度看，市场就是商品交换关系的总和

   营销学中的市场：指的是具有特定的需求或欲望，而且愿意并能够通过交换来满足这种需要和欲望的全部潜在顾客。

   一般意义的市场：是商品交易的场所，是显在和潜在买主的结合体，是买卖关系的总和。

   营销是通过创造和交换产品及价值，从而使个人或组织满足欲望和需要的社会和管理过程。

   阅读全文 »

1. What is web container ?

   Web container is the component in J2EE which is responsible for handle request from client. Web Server application like tomcat is used to support basic service for web container, e.g., receive request and forward reply to client.

   阅读全文 »

• 全选

  普通模式下， gg 回到文件开始，v 进入可视模式， G 将光标移到文件结束。

• 复制到系统粘贴板

  这个首先要看 vim 是否支持系统粘贴板 vim --version | grep "clipboard" 我这里 clipboard 前是 + 号，表示支持。如果是 - 号，可以百度下方法。

  普通模式下，使用 "+y 复制到粘贴板。

• 交换相邻字符顺序

  我编程时有时因为输入太快而导致字符顺序错误。比如将 return 输入成 retrun, endl 输入成 ednl。这样子的话将光标移到出现错误的第一个字符。然后普通模式下 xp。

• 正常模式转到插入模式

  • i 当前光标前插入， I 当前行首
  • a 当前光标后插入， A 当前行尾
  • o 下一行插入， O 上一行插入

• D： d$

• ?：从下而上查找， / 自上而下查找

• 保存新文件：:w 路径+文件名

• :!+bash命令：运行终端命令

• :s/old/new：将旧的替换成新的，默认为当前行

• :3，5s/old/new：从第 3 行到第 5 行替换

• :s/old/new/g：全局替换

最近读《Effective C++》时读到了 new-handler 一章，了解了 new/delete 一些知识，才知道原来 new/delete 是可以个性化的。
先说简单的一个收获，C++ new 失败后默认后抛出异常，如果我们想让他失败时返回空指针，则应该使用如下写法。

1

int *pi = new (std::nothrow) int[100000000000L];

• 《一些好的开发习惯》：公众号自我介绍，科学上网助手、记录、虚拟机文件共享，链接：https://mp.weixin.qq.com/s/VNlzYchotgBbqiTn53jAsg
• 《校招面试前的一些准备》：春招找实习的准备工作（时间，简历，自我介绍模板，渠道，技术准备，深入部分、项目部分），链接：https://mp.weixin.qq.com/s/yXIY_-osPMAsySRFimktoQ
• 《掌握基础 - 方能决胜秋招》：技术类准备的基础工作，及一些资源的推荐，链接：https://mp.weixin.qq.com/s/zSQbfLv1YWR2oMvQwGXmug
• 《我的春招之路（上）》：谱哥春招经历，面经，链接：https://mp.weixin.qq.com/s/1Nu0v1iXPnb4p2ztXIKjiQ
• 《我的春招之路（下）》：面经，总结，链接：https://mp.weixin.qq.com/s/Cgu50L-MOeMwNBg-Sk_t9A
• 《腾讯百度实习经历》：链接：https://mp.weixin.qq.com/s/BaxJPkw7DunMvcJIibq_gA
• 《我的秋招准备》：Linux C/C++ 常见问题整理及 C++ 常见问题列表，链接：https://mp.weixin.qq.com/s/ClrX-JUTh4ftF4ZFSDgHnQ
• 《秋招玄学贴》：秋招经历、一些面经、注意事项，链接：https://mp.weixin.qq.com/s/wsBPWQiS6l3XX0jPQRnLvw
• 《我的秋招之路 (上)》：对于秋招的建议，面经，链接：https://mp.weixin.qq.com/s/8PeaTnAMbVU-kvMaye3SGw
• 《我的秋招之路 (下)》：面经，Linux C/C++ 一些题目，链接： https://mp.weixin.qq.com/s/r6bsLFzwvYnaBs5MrvXbRQ
  阅读全文 »

传送门：Circuit Board

Problem

Description

Arsh recently found an old rectangular circuit board that he would like to recycle. The circuit board has R rows and C columns of squares.

Each square of the circuit board has a thickness, measured in millimetres. The square in the r-th row and c-th column has thickness Vr,c. A circuit board is good if in each row, the difference between the thickest square and the least thick square is no greater than K.

Since the original circuit board might not be good, Arsh would like to find a good subcircuit board. A subcircuit board can be obtained by choosing an axis-aligned subrectangle from the original board and taking the squares in that subrectangle. Arsh would like your help in finding the number of squares in the largest good subrectangle of his original board.

Problem

传送门

Description

Bundle is an animal researcher and needs to go observe K dogs. She lives on a horizontal street marked at metre increments with consecutive numbers 0, 1, 2, 3 and so on. She begins in her home, which is at position 0. There are also N dogs on the street. The i-th dog is Pi metres to the right of her home on the street (multiple dogs can share the same position).

最近转移到了 Ubuntu 系统上，配了一波环境，逐步适应了些 Vim，虽然一开始觉得没有补全无所谓的，可以练练实力，再安装插件觉得麻烦，但后面还是觉得没有补全少点什么，于是决定还是下个 Vim 补全的插件。大约刻之前在赵老板博客上看到过一个关于 Vim 补全的插件赵老板博文链接，所以打算用那个，也就是 YouCompleteMe。据说这是 Vim 最难安装的插件？

安装步骤并不算麻烦吧：

1. 安装 Vundle （Vim 插件管理）
2. 用 Vundle 安装编译 YouCompleteMe
3. 配置 YouCompleteMe

前期工作

1. 确认你的 vim 版本在 7.3.584 以上。
2. 确认你的电脑支持 Python 2.x。
3. 需要 Vundle（vim 的插件管理工具）来管理你的插件。
4. 安装脚本需要使用 CMake。

以上几点大家如果没有配置好的话，网上有很多很详细的教程，这里就不细讲了。（完全照抄赵老板博客）

Hello Ubuntu

安装 Ubuntu 18.04

这个网上教程有很多，我就不详述了。我来说下我遇到的一些坑（Win7 + Ubuntu），双显卡（Nvidia + Inter）。大一的时候未能成功，就是因为 Nvidia 的驱动问题。一开始遇到了安装时卡在 logo 界面的问题，Ubuntu 18.04 与前面不同的好像是选择 Try Ubuntu without install Install Ubuntu 时有了界面。这一下把我搞懵了，因为原来选择的时候按 e 可以编辑 grub 参数，这次不知道去哪里编辑了，尴尬。后面摸索了下发现 F6 有个其他选项，里面有个 nomodeset，勾选后便解决了这个问题。

传送门：BZOJ 5486 Fine Dining

Problem

Description

漫长的一天结束了，饥困交加的奶牛们准备返回牛棚。农场由 N 片牧场组成（2≤N≤50,000），方便起见编号为 1…

N。所有奶牛都要前往位于牧场 N 的牛棚。其他 N-1 片牧场中每片有一头奶牛。奶牛们可以通过 M 条无向的小路在牧场之间移动（1≤M≤100,000）。第 i 条小路连接牧场 ai 和 bi，通过需要时间 ti。每头奶牛都可以经过一些小路回到牛棚。由于饥饿，奶牛们很乐于在他们回家的路上停留一段时间觅食。农场里有 K 个有美味的干草捆，第 i 个干草捆的美味值为 yi。每头奶牛都想要在她回牛棚的路上在某一个干草捆处停留，但是她这样做仅当经过这个干草捆使她回牛棚的时间增加不超过这个干草捆的美味值。注意一头奶牛仅仅 “正式地” 在一个干草捆处因进食而停留，即使她的路径上经过其他放有干草捆的牧场；她会简单地无视其他的干草捆。

Input

第一行包含三个空格分隔的整数 N，M 和 K。

以下 M 行每行包含三个整数 ai，bi 和 ti，表示牧场 ai 和 bi 之间有一条需要 ti 时间通过的小路

（ai 不等于 bi，ti 为不超过 104 的正整数）。

以下 K 行，每行以两个整数描述了一个干草捆：该干草捆所在牧场的编号，以及它的美味值（一个不超过 10^9 的正整数）。

同一片牧场中可能会有多个干草捆。

Output

输出包含 N-1 行。

如果牧场 i 里的奶牛可以在回牛棚的路上前往某一个干草捆并且在此进食，则第 i 行为一个整数 1，否则为一个整数 0

Sample Input

4 5 1
1 4 10
2 1 20
4 2 3
2 3 5
4 3 2
2 7

Sample Output

1
1
1
在这个例子中，牧场 3 里的奶牛可以停留进食，因为她回去的时间仅会增加 6（从 2 增加到 8），而这个增加量并没有
超过干草捆的美味值 7。牧场 2 里的奶牛显然可以吃掉牧场 2 里的干草，因为这并不会导致她的最佳路径发生变化。
对于牧场 1 里的奶牛是一个有趣的情况，因为看起来她的最佳路径（10）可能会因为前去进食而有过大的增加量。
然而，确实存在一条路径使得她可以前去干草捆处停留：先到牧场 4，然后去牧场 2（吃草），然后回到牧场 4。

Solution

Idea

分层图最短路。两种状态，吃或未吃干草。$dis [i] [0]$ 表示未吃干草状态下到达 i 的最短时间，$dis [i][1]$ 则为吃干草状态下到达 i 的最短时间。

将牧场之间的距离看做为正，将干草看为负。如果 $dis [n][1] <= dis [n][0]$ ，则输出 1.

Code

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

#define MAXN 50050
#define MAXM 200050
#define INF 0x3f3f3f3f
typedef long long LL;

using namespace std;

int n, m, k;

struct ed
{
    int to, next, cost;
}edge[MAXM];

int tot;
int head[MAXN];
int has[MAXN], dis[MAXN][2];
bool vis[MAXN];

void addedge(int u, int v, int w)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].cost = w;
    head[u] = tot++;
}

void spfa()
{
    memset(dis, 0x3f, sizeof(dis));
    dis[n][0] = 0;
    queue<int> que;
    que.push(n);
    while(!que.empty())
    {
        int u = que.front();
        int v;
        que.pop();
        vis[u] = false;

        for(int i = head[u]; ~i; i = edge[i].next)
        {
            v = edge[i].to;
            if(dis[u][0] + edge[i].cost < dis[v][0])
            {
                dis[v][0] = dis[u][0] + edge[i].cost;
                if(!vis[v])
                {
                    que.push(v);
                    vis[v] = true;
                }
            }

            if(has[v] && dis[u][0] + edge[i].cost - has[v] < dis[v][1])
            {
                dis[v][1] = dis[u][0] + edge[i].cost - has[v];
                if(!vis[v])
                {
                    que.push(v);
                    vis[v] = true;
                }
            }

            if(dis[u][1] + edge[i].cost < dis[v][1])
            {
                dis[v][1] = dis[u][1] + edge[i].cost;
                if(!vis[v])
                {
                    que.push(v);
                    vis[v] = true;
                }
            }
        }
    }
}

int main()
{
    tot = 0;
    memset(head, -1, sizeof(head));

    scanf("%d%d%d", &n, &m, &k);
    int u, v, w;

    for(int i=0; i<m; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        addedge(u, v, w);
        addedge(v, u, w);
    }
    for(int i=0; i<k; i++)
    {
        scanf("%d%d", &u, &w);
        has[u] = max(has[u], w);
    }

    if(has[n])
    {
        for(int i=1; i<n; i++)
            puts("1");
        return 0;
    }
    spfa();
    for(int i=1; i<=n-1; i++)
    {
        if(dis[i][0] >= dis[i][1])
            puts("1");
        else
            puts("0");
    }

    return 0;
}