预测分数:100+0+60=160

Linux文件及目录的性能和权限

命令:

  1. [root@oldboy ~]# ls -lhi

  2. total 40K

  3. 24973 -rw——-. 1 root root 1.1K Dec
    10 16:02 anaconda-ks.cfg

  4.    15 -rw-r–r–. 1 root root 22K Dec
    10 16:02 install.log

  5.    17 -rw-r–r–. 1 root root 5.8K Dec
    10 16:00 install.log.syslog

率先排:inode(index
node)索引节点编号,文件要目录在磁盘里之绝无仅有标识,linux读取文件首先要读博到这文件的索引节点(类似书的目录)。

第二列:

第1独字符:文件类型,-普通文件,d目录。(windows扩展名.jpg,.avi)

第2—10独字符rw-r—r–:文件权限(r(read)读取权限、w(write)写权限,x(execute)执行权,-无权力)

第11个字符.:SELINUX相关。

其三排列:文件硬链接数。文件硬链接是文本之同时一个入口。硬链接inode一样。

季排列:文件之属主或用户。

第五排:文件对应之属组或用户组(团体)。

权力对应关系图:

图片 1

第六排:文件或者目录的深浅。

第七八九列:文件最近涂改时。

第十列:文件或者目录名。

实质上分数:100+0+60=160

mmpT1屡按照错了。。。

 

索引节点inode

T1遭遇

inode概述

硬盘要分区,然后格式化,创建文件系统。

inode,索引节点(index
node)。在每个linux存储设备或存储设备的分区(存储设备可以是硬盘、软盘、U盘等)被格式化为ext4文件系统后,一般还来零星组成部分:第一组成部分凡inode(很多单),第二有些是block(很多只)。

block是故来囤积实际多少用之,例如:照片、视频等便文书数量。inode就是用来储存这些数量性信息之(也不怕是ls
-l的结果),inode包含的属性信息包括文件大小、宿主、归属的用户组、读写权限、文件类型,修改时,还噙对文件实体的指针的效力(inode节点—block的呼应关系等),但是,inode唯独不带有文件称。

inode除了记录文件属性的音外,还见面吗每个文件进行信息索引,所以即便产生矣inode的数值。操作系统根据指令,即可通过inode的价值最抢之找到彼此呼应的文件实体。文件,inode、block之间的涉嫌表现下图:

图片 2

查看inode大小:

  1. #根分区

  2. [root@oldboy ~]# dumpe2fs
    /dev/sda3|grep -i “Inode size”

  1. dumpe2fs 1.41.12 (17-May-2010)

  2. Inode size: 256

  3. #boot分区

  4. [root@oldboy ~]# dumpe2fs
    /dev/sda1|grep -i “Inode size”

  1. dumpe2fs 1.41.12 (17-May-2010)

  2. Inode size: 128

查看inode大小:

  1. #boot分区

  2. [root@oldboy ~]# dumpe2fs
    /dev/sda1|grep -i “block size”

  1. dumpe2fs 1.41.12 (17-May-2010)

  2. Block size: 1024

  3. #根分区

  4. [root@oldboy ~]# dumpe2fs
    /dev/sda3|grep -i “block size”

  1. dumpe2fs 1.41.12 (17-May-2010)

  2. Block size: 4096

查阅挂载的磁盘inode使用状况:

  1. [root@oldboy ~]# df -i

  2. Filesystem Inodes IUsed IFree IUse%
    Mounted on

  3. /dev/sda3 479552 54520 425032 12% /

  1. tmpfs 127032 1 127031 1% /dev/shm
  1. /dev/sda1 51200 38 51162 1% /boot

查挂载的磁盘block使用状态:

  1. [root@oldboy ~]# df -h

  2. Filesystem Size Used Avail Use% Mounted
    on

  3. /dev/sda3 7.1G 1.4G 5.4G 21% /

  4. tmpfs 497M 0 497M 0% /dev/shm

  5. /dev/sda1 190M 27M 153M 16% /boot

有关inode的小结:

1、磁盘分区格式化ext4文件系统后会见转一定数量之inode和block。

2、inode的索引节点,作用是存文件之习性信息与作为文件的目录(指向文件之实业)。

3、ext3/ext4文件系统的block存放的凡文本之莫过于内容。

4、inode是一律块存储空间,c6请勿启动分区inode默认大小256字节,c5是128字节。

5、inode是平等串数字,不同之公文对应之inode(一差数字)在文件系统里是唯一的。

6、inode号相同的文本,互为刚链接文件(文件之以一个输入)。

7、一个文本为创造后起码要霸占一个inode和一个block。

8、block的高低相似有1k、2k、4k几种植,其中引分区等为1k,其他日常分区为4k(c6)。

9、如果一个文件特别可怜,可能占大半只block。

10、如果文件特别粗,至少占一个,并且剩余空间不克于其他文件使用。

11、inode大小与总量查看。

  1. [root@oldboy ~]# dumpe2fs
    /dev/sda3|egrep -i “block size|Inode
    size”

  2. dumpe2fs 1.41.12 (17-May-2010)

  3. Block size: 4096

  4. Inode size: 256

  5.    

  6. [root@oldboy ~]# dumpe2fs
    /dev/sda3|egrep -i “block count|Inode
    count”

  7. dumpe2fs 1.41.12 (17-May-2010)

  8. Inode count: 479552

  9. Block count: 1914624

  10. Reserved block count: 95731

12、查看inode的总量以及使用量命令df
-i。

13、生成和指定inode大小mkfs.ext4
-b 2048 -I 256 /dev/sdb1。

block的知识:

1、磁盘读取数据是按block为单位读取的。

2、一个文件或者占多只block。每读取一个block就会见吃一不行磁盘I/O。

3、如果要提升磁盘I/O性能,那么尽管假设尽可能一次性读取数据尽量的基本上。

4、一个block只能存放一个文书之始末,无论内容发生多有点。如果block
4k,那么存放1k的文书,剩余3k就浪费了。

5、block并非更老进一步好。block太特别对于有些文件存放就会浪费磁盘空间。例如:1000k的公文,block也4k,占用250单block,block为1k,占用1000只block。消耗I/O分别吗250潮与1000潮。

6、大文件(大于16k)一般安装block大一点,小文件(小于1k)一般设置block小一些。

7、block太可怜如4k,文件还是0.1k的,大量荒废磁盘空间。

8、block的安装为是格式化分区的时节,mkfs.ext4
-b 2048 -l 256 /dev/sdb。

9、文件于生时,block设置特别组成部分见面提升磁盘访问效率。

10、ext3/ext4文件一般安装为4k。

此时此刻的生环境一般安装为4k。特殊之政工,如视频可以加大block大小。

题材叙述

若是能收看第一书写的 friends呢。

—— hja

?座楼,立被市中 。

第?座楼,高度 ℎ?。

乃要平等初始选择座楼,跳。 在第 ?座楼准备超过得 ??的消费。
每次可过到其他一个还尚未过的楼上去。但是代价,另外一座楼底代价是个别可观不等绝对值
,最后一赖由楼上跳到地面不需要 要代价(只能跨到地上一不好)。为当匪越
要代价(只能跨到地上一不行)。为以无跳 ?的情事下,最多越几糟糕楼。
(一所楼 只能 跳一蹩脚 ,且每次 跳楼 都使 计算 准备 的花费 )

linux的文件类型和扩张名

输入输出格式

输入格式:

 

首先行个整数 ?,代表 楼的数。

连通下去一样实践 ?个整数代表 ??。

对接下去一样履 ?个整数代表 ℎ?。

说到底一行独整数 ?。

 

出口格式:

 

一行单整数 代表答案 。

 

linux中之文件类型

当linux系统中,可以说满均文件。文件类型包含有平凡文书、目录、字符设备文件、块设备文件、符号链接文件等。

万般文书(regular
file):第一单特性为”-“,按照文件内容,又盖可分为如下三栽:

1、纯文本文件(ascii):文件内容好一直读到数,例如:字母、数字相当于。可以为此cat命令读出文件内容。

2、二进制文件(binary):linux当中可执行文件(命令)就是属于这种格式。例如cat这个执行文书就是一个二进制文件。

3、数据格式文件(data):有些程序在运行的过程遭到会读取某些特定格式的文本,那些特定格式的公文可以吃喻为数据文件。例如:linux在用户登录时,都见面用登录的多少记录在/var/log/wtmp那个文件内,该文件是一个数据文件。通过last命令读出来。cat命令会宣读来乱码。因为它属于同一种非常格式的文书。

文件类型小结:

1、- regular
file普通文书

纯文本、二进制文件、数据文件。

2、d directory目录。

3、l
link符号链接或者软链接文件。

快捷方式,指向文件的实体。

4、字符文件,块设备文件

c character串口设备、猫

b block硬盘、光驱。

5、.sock进程中通信

s sock

6、管道文件

p

输入输出样例

输入样例#1: 复制

4
3 5 4 11
2 1
3 17

出口样例#1: 复制

3
【样例解释】
从1号楼跳到 2号楼再跳到 3号楼是一种 可行 的方案 。

linux下推广展名的作用

1、源码.tar、tar.gz、.tgz、.zip、.tar.bz表示压缩文件,创建命令tar、gzip、zip等。

2、.sh表示shell脚本文件,通过shell语言开发的先后。

3、.pl代表perl语言文件,通过perl语言开发的主次。

4、.py代表python语言文件,通过python语言开发的次第。

5、.html、.htm、.php、.jsp、.do表示网页语言的公文。

6、.conf表示系统服务的布文件。

7、.rpm代表rpm安装包文件。

说明

对于 30%的数据, 1≤?≤5。

于另外 20%的数码,所有 ℎ?相同。

对于另外 20%底多少, ??=0。

P104 zhx 遭遇

第 3 页 共 6 页

对于 100%的数据, 1≤?≤50,1≤??,ℎ?≤106,1≤?≤107。

 

莫见面开,不过70私分的算法貌似比好想

不过h相等的图景一般写炸了,。。。

 

图片 3图片 4

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<cmath>
  5 #include<algorithm>
  6 #include<ctime>
  7 using namespace std;
  8 const int MAXN=101;
  9 const int INF=0x7ffff;
 10 inline int read()
 11 {
 12     char c=getchar();int flag=1,x=0;
 13     while(c<'0'||c>'9')    {if(c=='-')    flag=-1;c=getchar();}
 14     while(c>='0'&&c<='9')     x=x*10+c-48,c=getchar();return x*flag;
 15 }
 16 int n,bg;//kashi
 17 struct node
 18 {
 19     int c;
 20     int h;
 21 }a[MAXN];
 22 int comp(const node &a,const node &b)
 23 {
 24     return a.c<b.c;
 25 }
 26 int comp2(const node &a,const node &b)
 27 {
 28     return a.h<b.h;
 29 }
 30 int ans=0;
 31 int vis[MAXN];
 32 int T;
 33 int dfs(int now,int spend,int have)
 34 {
 35     ans=max(ans,have);
 36     for(int i=1;i<=n;i++)
 37     {
 38         if(vis[i]==0&&spend+a[i].c+abs(a[now].h-a[i].h)<=T)
 39         {
 40             if(clock()-bg>=900)
 41             {
 42                 printf("%d",ans);
 43                 exit(0);
 44             }
 45             vis[i]=1;
 46             dfs(i,spend+a[i].c+abs(a[now].h-a[i].h),have+1);
 47             vis[i]=0;
 48         }
 49     }
 50 }
 51 int flagh=1;//高度是否相同
 52 int flagc=1;//花费是否都为0 
 53 inline void solvec()//花费都为0 
 54 {
 55     sort(a+1,a+n+1,comp2);
 56     for(int i=1;i<=n;i++)//从每一个点往后跳 
 57     {
 58         int nowjump=0;
 59         int nowspend=0;
 60         for(int j=i+1;j<=n;j++)
 61         {
 62             
 63             if(abs(a[j].h-a[j-1].h)+nowspend<=T)
 64             {
 65                 nowspend=abs(a[j].h-a[j-1].h)+nowspend;
 66                 nowjump+=1;
 67             }
 68             ans=max(ans,nowjump+1);
 69         }
 70     }
 71 }
 72 inline void solveh()
 73 {
 74     int nowjump=0;
 75     int nowspend=-1;
 76     if(a[1].c<=T)
 77     {
 78         nowspend=a[1].c;
 79         for(int i=2;i<=n;i++)
 80             if(nowspend+a[i].c<=T)
 81                 nowjump++,nowspend+=a[i].c;    
 82     }
 83     
 84     if(nowspend!=-1)    ans=max(ans,nowjump+1);
 85 }
 86 int main()
 87 {
 88 //    freopen("meet.in","r",stdin);
 89 //    freopen("meet.out","w",stdout);
 90     bg=clock();
 91     n=read();
 92     for(int i=1;i<=n;i++)    a[i].c=read();
 93     for(int i=1;i<=n;i++)    a[i].h=read();
 94     T=read();
 95     sort(a+1,a+n+1,comp);
 96     for(int i=1;i<=n;i++)
 97         if(a[i].c!=0)    flagc=0;
 98     for(int i=1;i<=n;i++)
 99         for(int j=1;j<=n;j++) 
100             if(a[i].h!=a[j].h&&i!=j)
101                 flagh=0;
102     if(flagc)    solvec();
103     if(flagh)    solveh();
104     
105     for(int i=1;i<=n;i++)
106         if(a[i].c<=T) 
107             vis[i]=1,dfs(i,a[i].c,1);
108     printf("%d",ans);
109     return 0;
110 }

莫名其妙丢20分

 

正解:

1(by myl)

考虑超过楼底聚合

定会来∑Ci

遵照高度排序

惊人差之代价==h5-h1

枚举最矮的楼,最高的楼

本C排序,一个一个之挑选

style=”font-size: 14pt;”>总花费Hj-Hi+Ci+Cj+∑选出来的Ci<=T的尽大值

复杂度:$O(N^3logN)$

2(by zhx)

dp

论从没有为高排序

style=”font-size: 14pt;”>$f[i][j]$表示停留于i,已经越了j栋楼,的极其小花费

枚举下一不善超过啊栋楼

$f[k][i+1]=min(
 f[k][j+1],f[i][j]+C[k]+abs(hk-hi)  )$

复杂度:$O(n^3)$

统计答案的时节枚举i,j观察是否<=T

 

 

图片 5图片 6

  1 #include <vector>
  2 #include <list>
  3 #include <map>
  4 #include <set>
  5 #include <queue>
  6 #include <deque>
  7 #include <stack>
  8 #include <bitset>
  9 #include <algorithm>
 10 #include <functional>
 11 #include <numeric>
 12 #include <utility>
 13 #include <sstream>
 14 #include <iostream>
 15 #include <iomanip>
 16 #include <cstdio>
 17 #include <cmath>
 18 #include <cstdlib>
 19 #include <ctime>
 20 #include<cstring>
 21 
 22 using namespace std;
 23 
 24 int f[100][100];
 25 
 26 struct rec
 27 {
 28     int d,t;
 29     rec(){}
 30     rec(int a,int b)
 31     {
 32         d=a;t=b;
 33     }
 34     bool operator<(const rec &a)const
 35     {
 36         return t<a.t;
 37     }
 38 }z[100];
 39 
 40 class GUMIAndSongsDiv1 {
 41 public:
 42     int maxSongs(vector <int> duration, vector <int> tone, int T) {
 43         int n=duration.size();
 44         for (int a=0;a<n;a++)
 45             z[a]=rec(duration[a],tone[a]);
 46         sort(z,z+n);
 47         memset(f,0x3f,sizeof(f));
 48         f[0][0]=0;
 49         f[0][1]=z[0].d;
 50         for (int a=1;a<n;a++)
 51             for (int b=0;b<=a+1;b++)
 52                 if (!b) f[a][b]=0;
 53                 else
 54                 {
 55                     for (int c=0;c<a;c++)
 56                         f[a][b]=min(f[a][b],f[c][b-1]+z[a].d+(b==1 ? 0 : z[a].t-z[c].t));
 57                 }
 58         int ans=0;
 59         for (int a=0;a<n;a++)
 60             for (int b=1;b<=n;b++)
 61                 if (f[a][b]<=T) ans=max(ans,b);
 62         return ans;
 63         
 64     }
 65 };
 66 
 67 
 68 //<%:testing-code%>
 69 //Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!
 70 // BEGIN KAWIGIEDIT TESTING
 71 // Generated by KawigiEdit 2.1.4 (beta) modified by pivanof
 72 bool KawigiEdit_RunTest(int testNum, vector <int> p0, vector <int> p1, int p2, bool hasAnswer, int p3) {
 73     cout << "Test " << testNum << ": [" << "{";
 74     for (int i = 0; int(p0.size()) > i; ++i) {
 75         if (i > 0) {
 76             cout << ",";
 77         }
 78         cout << p0[i];
 79     }
 80     cout << "}" << "," << "{";
 81     for (int i = 0; int(p1.size()) > i; ++i) {
 82         if (i > 0) {
 83             cout << ",";
 84         }
 85         cout << p1[i];
 86     }
 87     cout << "}" << "," << p2;
 88     cout << "]" << endl;
 89     GUMIAndSongsDiv1 *obj;
 90     int answer;
 91     obj = new GUMIAndSongsDiv1();
 92     clock_t startTime = clock();
 93     answer = obj->maxSongs(p0, p1, p2);
 94     clock_t endTime = clock();
 95     delete obj;
 96     bool res;
 97     res = true;
 98     cout << "Time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " seconds" << endl;
 99     if (hasAnswer) {
100         cout << "Desired answer:" << endl;
101         cout << "\t" << p3 << endl;
102     }
103     cout << "Your answer:" << endl;
104     cout << "\t" << answer << endl;
105     if (hasAnswer) {
106         res = answer == p3;
107     }
108     if (!res) {
109         cout << "DOESN'T MATCH!!!!" << endl;
110     } else if (double(endTime - startTime) / CLOCKS_PER_SEC >= 2) {
111         cout << "FAIL the timeout" << endl;
112         res = false;
113     } else if (hasAnswer) {
114         cout << "Match :-)" << endl;
115     } else {
116         cout << "OK, but is it right?" << endl;
117     }
118     cout << "" << endl;
119     return res;
120 }
121 int main() {
122     freopen("meet.in","r",stdin);
123     freopen("meet.out","w",stdout);
124 
125     vector<int> duration;
126     vector<int> tone;
127     int n,T;
128     scanf("%d",&n);
129     for (int a=1;a<=n;a++)
130     {
131         int v;
132         scanf("%d",&v);
133         duration.push_back(v);
134     }
135     for (int a=1;a<=n;a++)
136     {
137         int v;
138         scanf("%d",&v);
139         tone.push_back(v);
140     }
141     scanf("%d",&T);
142     GUMIAndSongsDiv1 *obj;
143     int answer;
144     obj = new GUMIAndSongsDiv1();
145     answer = obj->maxSongs(duration, tone, T);
146     printf("%d\n",answer);
147     /*bool all_right;
148     all_right = true;
149     
150     vector <int> p0;
151     vector <int> p1;
152     int p2;
153     int p3;
154     
155     {
156     // ----- test 0 -----
157     int t0[] = {3,5,4,11};
158             p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
159     int t1[] = {2,1,3,1};
160             p1.assign(t1, t1 + sizeof(t1) / sizeof(t1[0]));
161     p2 = 17;
162     p3 = 3;
163     all_right = KawigiEdit_RunTest(0, p0, p1, p2, true, p3) && all_right;
164     // ------------------
165     }
166     
167     {
168     // ----- test 1 -----
169     int t0[] = {100,200,300};
170             p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
171     int t1[] = {1,2,3};
172             p1.assign(t1, t1 + sizeof(t1) / sizeof(t1[0]));
173     p2 = 99;
174     p3 = 0;
175     all_right = KawigiEdit_RunTest(1, p0, p1, p2, true, p3) && all_right;
176     // ------------------
177     }
178     
179     {
180     // ----- test 2 -----
181     int t0[] = {1,2,3,4};
182             p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
183     int t1[] = {1,1,1,1};
184             p1.assign(t1, t1 + sizeof(t1) / sizeof(t1[0]));
185     p2 = 100;
186     p3 = 4;
187     all_right = KawigiEdit_RunTest(2, p0, p1, p2, true, p3) && all_right;
188     // ------------------
189     }
190     
191     {
192     // ----- test 3 -----
193     int t0[] = {9,11,13,17};
194             p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
195     int t1[] = {2,1,3,4};
196             p1.assign(t1, t1 + sizeof(t1) / sizeof(t1[0]));
197     p2 = 20;
198     p3 = 1;
199     all_right = KawigiEdit_RunTest(3, p0, p1, p2, true, p3) && all_right;
200     // ------------------
201     }
202     
203     {
204     // ----- test 4 -----
205     int t0[] = {87,21,20,73,97,57,12,80,86,97,98,85,41,12,89,15,41,17,68,37,21,1,9,65,4,67,38,91,46,82,7,98,21,70,99,41,21,65,11,1,8,12,77,62,52,69,56,33,98,97};
206             p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
207     int t1[] = {88,27,89,2,96,32,4,93,89,50,58,70,15,48,31,2,27,20,31,3,23,86,69,12,59,61,85,67,77,34,29,3,75,42,50,37,56,45,51,68,89,17,4,47,9,14,29,59,43,3};
208             p1.assign(t1, t1 + sizeof(t1) / sizeof(t1[0]));
209     p2 = 212;
210     p3 = 12;
211     all_right = KawigiEdit_RunTest(4, p0, p1, p2, true, p3) && all_right;
212     // ------------------
213     }
214     
215     if (all_right) {
216         cout << "You're a stud (at least on the example cases)!" << endl;
217     } else {
218         cout << "Some of the test cases had errors." << endl;
219     }
220     return 0;*/
221 }
222 // END KAWIGIEDIT TESTING

鬼畜的正解

 

 

linux系统硬链接和软链接

在linux系统中,链接可分为两种植,一种植是强项链接(Hard
Link),另一样栽为软链接或标志链接(Symbolic Link or Soft link)。

开创硬链接:ln 源文件
目标文件

创办软链接:ln -s
源文件 目标文件(目标文件不能够先有)

T2都市

硬链接

身残志坚链接是赖通过索引节点(Inode)来进展链接。在linux(ex2、ex3、ex4)文件系统中,保存在磁盘分区中的文本管是啊种且见面为它们分配一个号码,这个号码为号称索引节点编号(index
inode)简称inode,即于系统中文件的号。

于linux文件系统中,多独公文名指向与一个索引节点(inode)是正规且允许的。这种气象的文本就称硬链接。提示:硬链接文件就相当给文件的另外一个输入。硬链接的意向有是容一个文书拥有多个有效里程径名(多单输入),这样用户存储着之快照功能就是利用了是规律,增加一个快照就差不多了一个硬链接。

干什么一个文本建立了硬链接就是见面防止数据误删呢?

为文件系统(ex2)的规律是,只要文件的索引节点(inode
index)还有一个上述之硬链接。只去其中一个硬链接(即单独删除了拖欠公文之链接指向)并无影响索引节点本身和其余的链接(即数据文件实体并未给删),只有当文件之尾声一个链接给删除后,此时要是来新数据要存储到硬盘上经常要么系统经过类似fsck做磁盘检查的当儿。被删去文件之数据块及目录的链接才见面让放出,空间为新数据占用并挂。此时,数据就是重为无力回天查找回了。也就是说,在linux系统中,删除静态文件(没有经过调用)(目录为是文件)的基准是跟之有关的装有硬链接文件都给删除。

刚毅链接原理图:

图片 7

硬链接示意图:

图片 8

硬链接小结:

1、具有同样inode节点号的大都单公文是彼此为刚链接文件。

2、删除硬链接文件要删除源文件擅自之一,文件实体并未受删去。

3、只有去了源文件及所有对应之硬链接文件,文件实体才见面被删。

4、当所有的硬链接文件及源文件被去除后,再存新的数据会占用是文件的半空中,或者磁盘fsck检查的时光,删除的数量吧会见被网回收。

5、硬链接文件就是文本之同时一个进口(相当给超市的前门、后门一样)。

6、可以透过叫文件设置硬链接文件,来严防重要文件被误删。

7、通过执行命令”ln
源文件 硬链接文件”,即可形成创建硬链接。

8、硬链接文件可以据此rm命令去。

9、对于静态文件(没有经过正在调用的文书)来讲,当对应硬链接数为0(i_link),文件就吃删除。i_link的查看方(ls
-l结果的老三排)。

  1. [root@oldboy tmp]# mkdir /tmp/oldboy
    -p

  2. [root@oldboy tmp]# cd oldboy/

  1. [root@oldboy oldboy]# touch
    oldboyfile

  2. [root@oldboy oldboy]# echo “I am oldboy linux” >> oldboyfile

  1. [root@oldboy oldboy]# cat oldboyfile
  1. I am oldboy linux

  2. #inode链接数为1

  3. [root@oldboy oldboy]# ls -l
    oldboyfile

  4. -rw-r–r– 1 root root 18 Dec 12 11:04
    oldboyfile

  5. [root@oldboy oldboy]# ln oldboyfile
    oldboyfile_hard_link

  6. #inode链接数变为2

  7. [root@oldboy oldboy]# ls -l
    oldboyfile

  8. -rw-r–r– 2 root root 18 Dec 12 11:04
    oldboyfile

  9. #硬链接inode号一样

  10. [root@oldboy oldboy]# ls -lhi
    oldboyfile*

  11. 3209 -rw-r–r– 2 root root 18 Dec 12
    11:04 oldboyfile

  12. 3209 -rw-r–r– 2 root root 18 Dec 12
    11:04 oldboyfile_hard_link

  13. #文件内容相同

  14. [root@oldboy oldboy]# cat oldboyfile

  1. I am oldboy linux

  2. [root@oldboy oldboy]# cat
    oldboyfile_hard_link

  3. I am oldboy linux

  4. #删除源文件

  5. [root@oldboy oldboy]# rm -f
    oldboyfile

  6. [root@oldboy oldboy]# cat
    oldboyfile_hard_link

  7. I am oldboy linux

题目叙述

而是力所能及观看第二修之 friends呢。

—— laekov

塔立于市, 攀登上塔,能够到达更远的地方。但是急需破解谜 题。仍然发生
?个数,但并无为您 而是了?×?−12单数,代表她简单之 和。那么,这
?个数是多少吧?

软链接

软链接(Soft
Link)也称符号链接(Symbolic
Link)。linux里之软链接文件就好像于windows系统中的快捷方式。linux里之软链接文件实际上是一个非同寻常的文件,文件类型是i。软链接文件实际上可以知道吧一个文本文件,这个文件中隐含有软链接指向外一个来源文件之职务信息内容,因此,通过顾这个”快捷方式”就可以很快定位及软链接所指向的源文件实体。

软链接原理图:

图片 9

顾:创建软链接文件是内需在的,要开创的软链接文件是勿克是的,要为此ln命令创建。

软链接小结:

1、软链接类似windows的快捷方式(可以经readlink查看其对)。

2、软链接类似一个文件文件,里面存的凡根源文件的路径,指向源文件实体。

3、删除源文件,软链接文件还留存,但是无法访问指向的源文件路径内容了。

4、失效的时刻一般是白配红底闪烁提示。

5、执行命令”ln -s
源文件 软链接文件”,即可完成创建软链接(目标不能够是)。

6、软链接和源文件是不同档次的文件,也是殊之文书,inode号不同。

7、删除软链接文件可以就此rm命令。

目录创建软链接:

  1. [root@oldboy oldboy]# mkdir
    oldboydir

  2. [root@oldboy oldboy]# ln -s
    oldboydir oldboydir_soft_link

  3. [root@oldboy oldboy]# ls -l

  4. total 8

  5. drwxr-xr-x 2 root root 4096 Dec 12
    14:45 oldboydir

  6. lrwxrwxrwx 1 root root 9 Dec 12 14:46
    oldboydir_soft_link -> oldboydir

总:当去原始文件oldboyfile后,其刚链接文件oldboyfile_hard_link不吃影响,对应之多少还是留存,但是其相应的软链接文件oldboyfile_soft_link失效了,找不顶来自文件了,此时,可以去除软链接文件重建,或者创造一个oldboyfile_hard_link的硬链接文件oldboyfile。

店家生产软链接作用:

1、编译软件时指定版本号(/application/apache2.2.23),访问时要去丢版本号(/application/apache),可以装软链接到编译的路。所有程序还看软链接文件(/application/apache),当软件升级高版本后,只待去链接文件重建到强版本路径的软链接即可(/application/apache)。

2、企业代码发布时(php程序),需要拿具备代码传到一个初发表的现目录或者新的站点目录。发布时要使用mv,也可以重建软链接指向到这新的旋目录或者新的站点目录。

3、不便于目录移动,使用ln
-s。

至于文件之链接小结

1、删除软链接oldboyfile_soft_link,对oldboyfile、oldboyfile_hard_link无影响;

大局结论:删除软链接文件对源文件和硬链接文件管其他影响。

2、删除硬链接oldboyfile_hard_link,对oldboyfile、oldboyfile_soft_link都任影响;

全局结论:删除硬链接文件对源文件与软链接文件管其他影响。

3、删除源文件oldboyfile,对硬链接oldboyfile_hard_link没有影响,但是会促成软链接oldboyfile_soft_link失效;

全局结论:删除源文件,对硬链接文件并未影响,但是会招致软链接文件失效,呈现红底白字闪烁。

4、同时删除源文件oldboyfile,硬链接文件oldboyfile_hard_link,整个文件会真正的叫剔除。

5、很多硬件配备中之快照功能,就是使了血气链接的法则。

6、源文件及硬链接文件具有同样之索引节点号,可以当是跟一个文本或者一个文件之差不多独输入。

7、源文件和软链接文件的索引节点号不同,是见仁见智之文书,软链接相当给来文件的快捷方式,含有源文件之职位指向。

有关目录链接小结:

1、对于目录,不可以创建硬链接,但足以创造软链接。

2、对于目录的软链接是生产状况运维中常用的技巧。

3、目录的硬链接不能够过文件系统(从硬链接原理可以理解)。

4、每个目录下面都生一个硬链接”.”号,和相应上级目录的硬链接”..”。

5、在父目录里创建一个子目录,父目录的接连数加1(子目录里都发生..来因为父目录)。但是当父目录里创建文件,父目录的链接数不见面增多。

输入输出格式

输入格式:

 

一行独整数 ?。

接通下一样行 ?×?−12单数,代表个别底与。

 

出口格式:

 

第一行个整数 ?代表解的个数 。

连下去 ?行 ,每行 ,每?个数代表一如既往组解,从小到特别排列。的次第
按照字典个数代表同样组解,从小到充分排列。的相继
按照字典个数代表一律组解,从小到不行排列。的一一 按照字典从大到多少排列。

 

linux下文件去原理

输入输出样例

输入样例#1: 复制

4
3 5 4 7 6 5

输出样例#1: 复制

1
1 2 3 4

输入样例#2: 复制

4
11 17 21 12 20 15

出口样例#2: 复制

2
4 7 8 13
3 8 9 12
P104 zhx 都市
第 5 页 共 6 页

去原理描述

linux的公文名是存在父目录的block里面,并针对这文件之inode节点,这个文件之inode节点再标记指向存放这个文件之block的数据块。我们去一个文书,实际上并无是清楚inode节点和block的多少。只是于是文件的父目录里面的block中,删除这个文件之讳,从而使这个文件称没有,并且无法对是文件之inode节点,当没公文名指向此inode节点的时光,会同时放inode节点和存放这个文件的数据块,并创新inode
MAP和block MAP今后深受这些位置好用于放置任何文件数量。

说明

对于 30%底数量, 1≤?≤5,?个数均无越 10。

对于 60%的数额, 1≤?≤50,?个数均未超过 100。

对此 100%之数量, 1≤?≤300,?个数均未跳 108。

 

不会做,

末没有工夫了,连暴力都没打。

 

正解

先期对给来和枚举的往往的往往进行排序

设枚举的高频也$a_1,a_2$

被闹的一再为$b_1,b_2$

性质:

a1+a2==b1

a1+a3==b2

设a2+a3=x

枚举a2+a3对等于b里面的哪位数

对此持有的ai,都进展这个操作

老是解除a1,a2,a3

时复杂度:$O(n^4)≈O(n^3)$

 

图片 10图片 11

 1 v#include<cstdio>
 2 #include<cstdlib>
 3 #include<cstring>
 4 #include<algorithm>
 5 
 6 using namespace std;
 7 
 8 const int maxn=310;
 9 
10 int n,m,res[maxn],ans[maxn][maxn],z[maxn*maxn],cnt;
11 
12 bool use[maxn*maxn];
13 
14 void check(int p)
15 {
16     memset(use,false,sizeof(use));
17     if ((z[1]+z[2]+z[p])&1) return;
18     res[1]=(z[1]+z[2]+z[p])/2-z[p];
19     res[2]=z[1]-res[1];
20     res[3]=z[2]-res[1];
21     use[1]=use[2]=use[p]=true;
22     for (int a=4,b=3;a<=n;a++)
23     {
24         while (b<=m && use[b])
25             b++;
26         if (b>m) return;
27         res[a]=z[b]-res[1];
28         use[b]=true;
29         for (int c=2;c<a;c++)
30         {
31             if (res[c]>res[a]) return;
32             int v=res[c]+res[a];
33             int p=lower_bound(z+1,z+m+1,v)-z;
34             if (z[p]!=v) return;
35             int px=p;
36             while (px && z[px]==z[p])
37                 px--;
38             px++;
39             while (px<=m && z[px]==z[p] && use[px])
40                 px++;
41             if (z[px]!=z[p] || use[px]) return;
42             p=px;
43             use[p]=true;
44         }
45     }
46     cnt++;
47     for (int a=1;a<=n;a++)
48         ans[cnt][a]=res[a];
49 }
50 
51 int main()
52 {
53     freopen("city.in","r",stdin);
54     freopen("city.out","w",stdout);
55 
56     scanf("%d",&n);
57     m=n*(n-1)/2;
58     for (int a=1;a<=m;a++)
59         scanf("%d",&z[a]);
60     sort(z+1,z+m+1);
61     for (int a=3;a<=m;)
62     {
63         check(a);
64         int b=a;
65         while (b<=m && z[b]==z[a])
66             b++;
67         a=b;
68     }
69     printf("%d\n",cnt);
70     for (int a=1;a<=cnt;a++)
71         for (int b=1;b<=n;b++)
72         {
73             printf("%d",ans[a][b]);
74             if (b==n) printf("\n");
75             else printf(" ");
76         }
77 
78     return 0;
79 }

View Code

 

 

 

 

linux下文件去的规律

图片 12

文本去控制的变量:

i_link:文件硬链接数量

i_count:引用计数(有一个程序使用i_count加1)

文本去的规则:

i_link=0 and
i_count=0

证明:以上图形i_link=2和i_count=1。

linux是经link的数来控制文件去的,只有当一个文书未存在任何link的时光,这个文件才见面吃剔除。一般的话,每个文件都起2独link计数器i_link和i_count。

i_count的含义是目前文件使用者(或被调用)的数,i_link是磁盘的援计数器。当一个文件被某某一个过程引用时,对应i_count数就见面增多;当创建文件之硬链接的上,对应i_link数就见面加。

对删除命令rm而言,实际就是是缩减磁盘引用计数i_link。这里就会见来一个问题,如果一个文本在被某进程调用,而用户可尽rm操作把公文去了,那么会冒出什么结果为?

当用户执行rm操作删除文件后,再实践ls或者其它文件管理命令,无法再找到这个文件了,但是调用这个删除的文本的进程也以继承健康实施,依然能够起文本被正确的读取及写副内容。这还要是胡吧?
即是为rm操作只是将文件的i_link减少了,如果没有外的链接i_link就吧0了;但由于拖欠公文还让进程引用。因此,此文件对应的i_count并无为0,所以就是实施rm操作,但系统并无当真去这个文件,当就出i_link和i_count都为0的时光,这个文件才见面真给剔除。也就是说,还亟需免去该过程对该文件的调用才行。

i_link及i_count是文本去的实条件,但是当文件没有吃调用时,执行了rm操作删除文件后是否还可找寻回给删除的公文也?

rm操作只是以文件之i_link减少了,或者说置0了,实际就是是将文件称及inode的链接删除了,此时,并从未去除文件之实业即(block数据块),此时,如果立刻停止机器工作,数据是得找寻回的,如果此时前仆后继写副数据,那么新数据就是可能于分配到于剔除的数据的block数据块,此时,文件就见面真正的回收了。

实验:inode耗尽。

查新增的磁盘:

  1. #查新增的磁盘

  2. [root@oldboy ~]# fdisk -l

  3.    

  4. Disk /dev/sda: 8589 MB, 8589934592
    bytes

  5. 255 heads, 63 sectors/track, 1044
    cylinders

  6. Units = cylinders of 16065 * 512 =
    8225280 bytes

  7. Sector size (logical/physical): 512
    bytes / 512 bytes

  8. I/O size (minimum/optimal): 512 bytes /
    512 bytes

  9. Disk identifier: 0x00037eb4

  10.    

  11.    Device Boot Start End Blocks Id
    System

  12. /dev/sda1 * 1 26 204800 83 Linux

  1. Partition 1 does not end on cylinder
    boundary.

  2. /dev/sda2 26 91 524288 82 Linux swap /
    Solaris

  3. Partition 2 does not end on cylinder
    boundary.

  4. /dev/sda3 91 1045 7658496 83 Linux

  1.    

  2. Disk /dev/sdb: 106 MB, 106954752 bytes
    #增产的磁盘

  3. 64 heads, 32 sectors/track, 102
    cylinders

  4. Units = cylinders of 2048 * 512 =
    1048576 bytes

  5. Sector size (logical/physical): 512
    bytes / 512 bytes

  6. I/O size (minimum/optimal): 512 bytes /
    512 bytes

  7. Disk identifier: 0x00000000

格式化:

  1. [root@oldboy ~]# mkfs -t ext4
    /dev/sdb

  2. mke2fs 1.41.12 (17-May-2010)

  3. /dev/sdb is entire device, not just one partition!

  1. Proceed anyway? (y,n) y

  2. Filesystem label=

  3. OS type: Linux

  4. Block size=1024 (log=0)

  5. Fragment size=1024 (log=0)

  6. Stride=0 blocks, Stripe width=0 blocks

  1. 26208 inodes, 104448 blocks

  2. 5222 blocks (5.00%) reserved for the super user

  3. First data block=1

  4. Maximum filesystem blocks=67371008

  1. 13 block groups

  2. 8192 blocks per group, 8192 fragments
    per group

  3. 2016 inodes per group

  4. Superblock backups stored on blocks:

  1.         8193, 24577, 40961, 57345,
    73729

  2.    

  3. Writing inode tables: done

  4. Creating journal (4096 blocks): done

  1. Writing superblocks and filesystem
    accounting information: done

  2.    

  3. This filesystem will be automatically
    checked every 39 mounts or

  4. 180 days, whichever comes first. Use
    tune2fs -c or -i to override.

收回机关检查:

  1. [root@oldboy ~]# tune2fs -c -1
    /dev/sdb

  2. tune2fs 1.41.12 (17-May-2010)

  3. Setting maximal mount count to -1

挂载:

  1. [root@oldboy ~]# mount -t ext4 -o
    defaults /dev/sdb /tmp/app/log

  2. [root@oldboy ~]# df -h

  3. Filesystem Size Used Avail Use% Mounted
    on

  4. /dev/sda3 7.1G 1.4G 5.4G 21% /

  5. tmpfs 497M 0 497M 0% /dev/shm

  6. /dev/sda1 190M 27M 153M 16% /boot

  1. /dev/sdb 95M 1.6M 89M 2% /tmp/app/log

查看inode:

  1. [root@oldboy ~]# cd /tmp/app/log/
  1. [root@oldboy log]# df -i

  2. Filesystem Inodes IUsed IFree IUse%
    Mounted on

  3. /dev/sda3 479552 54527 425025 12% /

  1. tmpfs 127032 1 127031 1% /dev/shm
  1. /dev/sda1 51200 38 51162 1% /boot
  1. /dev/sdb 26208 11 26197 1% /tmp/app/log

创建26220个文件:

  1. [root@oldboy log]# for n in
    `seq 26220`;do touch stu$n;done
  1. touch: cannot touch `stu26198′: No
    space left on device

  2. touch: cannot touch `stu26199′: No
    space left on device

  3. touch: cannot touch `stu26200′: No
    space left on device

  4. touch: cannot touch `stu26201′: No
    space left on device

  5. touch: cannot touch `stu26202′: No
    space left on device

  6. touch: cannot touch `stu26203′: No
    space left on device

  7. touch: cannot touch `stu26204′: No
    space left on device

  8. touch: cannot touch `stu26205′: No
    space left on device

  9. touch: cannot touch `stu26206′: No
    space left on device

  10. touch: cannot touch `stu26207′: No
    space left on device

  11. touch: cannot touch `stu26208′: No
    space left on device

  12. touch: cannot touch `stu26209′: No
    space left on device

  13. touch: cannot touch `stu26210′: No
    space left on device

  14. touch: cannot touch `stu26211′: No
    space left on device

  15. touch: cannot touch `stu26212′: No
    space left on device

  16. touch: cannot touch `stu26213′: No
    space left on device

  17. touch: cannot touch `stu26214′: No
    space left on device

  18. touch: cannot touch `stu26215′: No
    space left on device

  19. touch: cannot touch `stu26216′: No
    space left on device

  20. touch: cannot touch `stu26217′: No
    space left on device

  21. touch: cannot touch `stu26218′: No
    space left on device

  22. touch: cannot touch `stu26219′: No
    space left on device

  23. touch: cannot touch `stu26220′: No
    space left on device

上述可以看看inode耗尽,不能够继承开创文件。

磁盘空间未满:

  1. [root@oldboy log]# df -h

  2. Filesystem Size Used Avail Use% Mounted
    on

  3. /dev/sda3 7.1G 1.4G 5.4G 21% /

  4. tmpfs 497M 0 497M 0% /dev/shm

  5. /dev/sda1 190M 27M 153M 16% /boot

  1. /dev/sdb 95M 2.1M 88M 3% /tmp/app/log

inode耗尽:

  1. [root@oldboy log]# df -i

  2. Filesystem Inodes IUsed IFree IUse%
    Mounted on

  3. /dev/sda3 479552 54527 425025 12% /

  1. tmpfs 127032 1 127031 1% /dev/shm
  1. /dev/sda1 51200 38 51162 1% /boot
  1. /dev/sdb 26208 26208 0 100%
    /tmp/app/log

删除:

  1. [root@oldboy log]# find ./ -type
    f|xargs rm -f

  2. [root@oldboy log]# ls|xargs rm -f

查看inode:

  1. [root@oldboy log]# df -i

  2. Filesystem Inodes IUsed IFree IUse%
    Mounted on

  3. /dev/sda3 479552 54527 425025 12% /

  1. tmpfs 127032 1 127031 1% /dev/shm
  1. /dev/sda1 51200 38 51162 1% /boot
  1. /dev/sdb 26208 11 26197 1% /tmp/app/log

总结:ln命令不克针对目录创建硬链接,但足本着目录创建软链接,对于目录的软链接吗是生育场面运维中常用之效用。

T3街灯

linux系统用户以及用户组

linux用户划分:

1、超级用户

root uid=0 gid=0。

2、虚拟用户

存在linux中没有实际意义,满足文件要程序运行的内需而创造的。不能够登录,不能够采取,UID、GID范围1——499
。在/etc/passwd中末尾以nologin结尾。

3、普通用户

领队root创建的用户,UID、GID从500开头。

linux系统下之账户文件着重有/etc/passwd、/etc/shadow、/etc/group、/etc/gshadow文件

passwd文件中一行的一一字段简述

  1. [root@oldboy tmp]# cat /etc/passwd
  1. root:x:0:0:root:/root:/bin/bash

账号名称:账号密码:账号UID:账号组GID:用户征:用户家目录:shell解释器

shadow文件中一行的次第字段详细说明

字段名称

注释说明

账号名称

用户的账号名称

账号密码

用户密码,这是加密过的口令

最近更改密码的时间

从1970年1月1日起,到用户最近一次更改口令的天数

禁止修改密码的天数

从1970年1月1日起,到用户可以更改密码的天数

用户必须更改口令的天数

从1970年1月1日起,到用户必须更改密码的天数

警告更改密码的期限

在用户密码过期前多少天提醒用户更改密码

不活动时间

在用户密码过期之后到禁用账号的天数

失效时间

从1970年1月1日起,到用户被禁用的天数(useradd -f)

标志

保留

   

ls
-l:显示的时日是改时间。

  1. [root@oldboy tmp]# ls -l
    –time-style=long-iso

  2. total 16

  3. drwxr-xr-x 3 root root 4096 2016-12-12
    13:18 app

  4. drwxr-xr-x 3 root root 4096 2016-12-12
    15:52 application

  5. drwxr-xr-x 2 root root 4096 2016-12-12
    15:49 oldboy

  6. -rw-r–r– 1 root root 18 2016-12-12
    11:04 oldboyfile_hard_link2

  7. -rw——-. 1 root root 0 2016-12-10
    15:53 yum.log

文件的日子:

Access: 2016-12-11
20:05:12.647999994 +0800(访问时)find -atime

Modify: 2016-12-10
16:02:10.162999297 +0800(修改时,内容发生变化)find -mtime

Change: 2016-12-10
16:02:10.162999297 +0800(变化时,包含Modify、权限、属主、用户组)find
-ctime

stat命令查看时等于的性能

问题叙述

公是能够看第三修的 friends呢。

—— aoao

街上的灯显示起,指引向在天路 街上之灯火显示起,指引向方远处路
街上之灯火亮起,指引向在角落路 街上的灯火亮起,指引向方远处路
街上的灯显示起,指引向在天涯路 。每个街灯上且有一样频, 每个街灯上还来一致勤,
每个街灯上都出平等往往, 每个街灯上还发生相同再三, 每次询问, 每次询问,
第?个街灯到第 ?个街灯上的数模 ?等于 ?的生几独。

linux正则表达式

动用正则表达式注意事项:

1、linux正则相似为实行呢单位配合处理的。

2、注意字符集,export
LC_ALL=C。

基本功正则表达式:元字符意义BRE(basic
regular expression)。

1、^word搜索以word开头的。vi
^一行的始发。

2、word$搜索以word结尾的。vi
$一行的末段。

3、^$表示空行。

4、.代表都不得不表示擅自一个字符。

5、\例如\.只代表点本身,转义符号,让有不同寻常地位意义之字符脱掉马甲还原原型。

6、*例如o*重复0独或多个前面的一个字符。

7、.*配合有字符。^.*坐随机多只字符开头。

8、[abc]匹配配字符集合内的随意一个字符[a-zA-Z],[0-9]。

9、[^abc]配合不含有^后之自由一个字符。

10、a\{n,m\}重复n到m次前一个再度的字符。如果就此egrep、grep
-E或sed -r可以错过丢斜线。

\{n,\}重复至少n次前一个重复的字符。

\{,m\}无效

\{n\}重复n次前面一个再的字符。

壮大的正则表达式:

1、+重复一个要么一个以上前面的字符。

2、?重复0或一个0前方的字符。

3、|用或的艺术查找多只入的字符串。

4、()找出”用户组”字符串。

安别名过滤的始末展示颜色:

  1. [root@oldboy tmp]# alias grep=’grep
    –color=auto’

过滤以m开头

  1. [root@oldboy tmp]# grep ^m
    oldboy.log

过滤以m结尾

  1. [root@oldboy tmp]# grep “m$” oldboy.log

过滤空行显示

  1. [root@oldboy tmp]# grep -v “^$” oldboy.log

过滤空行显示行号

  1. [root@oldboy tmp]# grep -vn “^$” oldboy.log

匹配以.结尾

  1. [root@oldboy tmp]# grep “\.$” oldboy.log

准匹配-o

  1. [root@oldboy tmp]# grep -o “0*” oldboy.log

grep一般常用参数:

-a:在二进制文件被坐文件文件的主意搜索数据。

-c:计算找到”搜索字符串”的次数。

-o:仅展示出相当配regexp的情节(用于统计出现在文中的次数)。

-i:忽略大小写的不同,所有大大小小写视为等同。

-n:在行首显示行号。

-v:反往选择,即显示没有”搜索字符串”的情节之那么一行。

-E:扩展的grep,及egrep。

–color=auto:以一定颜色高亮显示匹配关键字。

-A:After的意,显示匹配配字符串及其后n行的数目。

-B:Before的意思,显示匹配配字符串及其前n行的多少。

-C:显示匹配配字符串及其前后各num行。

取出ip地址:

方法一:

  1. [root@oldboy ~]# ifconfig eth0|sed
    -n ‘2p’

  2.           inet addr:192.168.93.128
    Bcast:192.168.93.255 Mask:255.255.255.0

  3. [root@oldboy ~]# ifconfig eth0|sed
    -n ‘2p’|sed -r ‘s#^.*addr:(.*) Bcast:.*$#\1#g’

  4. 192.168.93.128

方法二:

  1. [root@oldboy ~]# ifconfig eth0|sed
    -nr ‘2s#^.*addr:(.*) Bcast:.*$#\1#gp’

  2. 192.168.93.128

取出HWaddr:

方法一:

  1. [root@oldboy ~]# ifconfig eth0|sed
    -n ‘1p’|sed -r ‘s#^.*net (.*) 00:.*$#\1#g’

  2.  HWaddr

方法二:

  1. [root@oldboy ~]# ifconfig eth0|sed
    -nr ‘1s#^.*net (.*) 00:.*$#\1#gp’

  2.  HWaddr

stat
/etc/hosts中取出0644:

  1. [root@oldboy ~]# stat /etc/hosts|sed
    -nr ‘4s#^.*ess: \((.*)/-.*$#\1#gp’

  2. 0644

输入输出格式

输入格式:

 

率先行两独数 ?,?,代表街灯的个数 和了解。

连下去一样履行 ?个数,代表 街灯及之勤。

接下去 ?行,每季个数 ?,?,?,?代表同组了解。

 

输出格式:

 

对每次询问,输出一行代表答案 。

 

输入输出样例

输入样例#1: 复制

5 2
1 5 2 3 7
1
3 2 2 5 3 0

出口样例#1: 复制

2
1

说明

对于 30%的数据, 1≤?,?≤103。

对于另外 30%之 数据,每次询问?一样。

于 100%之数据, 1≤?,?≤105,街灯上的数不跳 104,1≤?≤109。

 

30分凡是武力

另外30分可为此莫队历届。。

只是标程是为此链表做的

图片 13图片 14

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<cmath>
 5 #include<map>
 6 #include<algorithm>
 7 using namespace std;
 8 const int MAXN=1e6;
 9 const int INF=0x7ffff;
10 inline int read()
11 {
12     char c=getchar();int flag=1,x=0;
13     while(c<'0'||c>'9')    {if(c=='-')    flag=-1;c=getchar();}
14     while(c>='0'&&c<='9')     x=x*10+c-48,c=getchar();return x*flag;
15 }
16 int n,m;
17 int a[MAXN];
18 struct node
19 {
20     int l,r,p,v,id;
21 }q[MAXN];
22 int out[MAXN];
23 int flag=1;//p是否都相等 
24 int ansout=0;
25 int mod=0;
26 int base[MAXN];
27 //map<int,int>happen;
28 int happen[2*MAXN*10+10];
29 int comp(const node &a,const node &b)
30 {
31     if(base[a.l]==base[b.l])
32         return base[a.r]<base[b.r];
33     else return base[a.l]<base[b.l];
34 }
35 inline void dele(int pos)
36 {
37     happen[a[pos]%mod]--;
38 }
39 inline void add(int pos)
40 {
41     happen[a[pos]%mod]++;
42 }
43 inline void modui()
44 {
45     int ll=0,rr=-1;
46     int now=0;
47     for(int i=1;i<=m;i++)
48     {
49         while(ll<q[i].l)    dele(ll),ll++;
50         while(ll>q[i].l)    add(ll-1),ll--;
51         while(rr<q[i].r)    add(rr+1),rr++;
52         while(rr>q[i].r)    dele(rr),rr--;
53         out[q[i].id]=happen[q[i].v];
54     }
55     for(int i=1;i<=m;i++)
56         printf("%d\n",out[i]);
57 }
58 int main()
59 {
60    // freopen("light.in","r",stdin);
61    // freopen("light.out","w",stdout);
62     n=read(),m=read();
63     int p=sqrt(n);
64     for(int i=1;i<=n;i++)    base[i]=(i-1)/p;
65     for(int i=1;i<=n;i++)    a[i]=read();
66     for(int i=1;i<=m;i++)
67     {
68         q[i].l=read();
69         q[i].r=read();
70         q[i].p=read();
71         q[i].v=read();
72         q[i].id=i;
73         if(i>=2&&q[i].p!=q[i-1].p)    flag=0;
74     }
75     if(flag&&n>=1e3&&m>=1e3)
76     {
77         sort(q+1,q+m+1,comp);
78         mod=q[1].p;
79         static map<int,int>happen;
80         modui();
81         return 0;
82     }
83     for(int i=1;i<=m;i++)
84     {
85         int ans=0;
86         for(int j=q[i].l;j<=q[i].r;j++)
87             if(a[j]%q[i].p==q[i].v)
88                 ans++;
89         printf("%d\n",ans);
90     }
91     return 0;
92 }

莫队

 

 

30分

暴力

60

把%p的余数扔到vector||链表||某个数据结构中

老是二瓜分出l的位置和r的位置

空中复杂度:$O(N)$

100

对p分块

p<=100对各级一个了解预处理

p>100

考虑a[i]%p==v

的值为v+p.v+kp。。

枚举k,k<=100

 

图片 15图片 16

 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 
 5 using namespace std;
 6 
 7 const int maxn = 100009;
 8 const int maxv = 10000;
 9 const int bsz = 100;
10 const int maxb = 103;
11 
12 int n, m;
13 int a[maxn], vb[maxb][maxb], ve[maxb][maxb];
14 int xb[maxn], xe[maxn];
15 int i_buf[maxn * maxb * 2], tib;
16 
17 void pre() {
18     memset(ve, 0, sizeof(ve));
19     memset(xe, 0, sizeof(xe));
20     for (int i = 1; i <= n; ++ i)
21         ++ xe[a[i]];
22     for (int i = 0; i <= maxv; ++ i) {
23         xb[i] = tib;
24         tib += xe[i];
25         xe[i] = xb[i];
26     }
27     for (int i = 1; i <= n; ++ i)
28         i_buf[xe[a[i]] ++] = i;
29     for (int m = 1; m <= bsz; ++ m) {
30         for (int i = 1; i <= n; ++ i)
31             ++ ve[m][a[i] % m];
32         for (int i = 0; i < m; ++ i) {
33             vb[m][i] = tib;
34             tib += ve[m][i];
35             ve[m][i] = vb[m][i];
36         }
37         for (int i = 1; i <= n; ++ i)
38             i_buf[ve[m][a[i] % m] ++] = i;
39     }
40 }
41 
42 int queryb(int l0, int r0, int p, int k) {
43     if (vb[p][k] == ve[p][k])
44         return 0;
45     int *x1 = lower_bound(i_buf + vb[p][k], i_buf + ve[p][k], l0);
46     int *x2 = upper_bound(i_buf + vb[p][k], i_buf + ve[p][k], r0);
47     return x2 - x1;
48 }
49 
50 int querys(int v, int l0, int r0) {
51     if (xb[v] == xe[v])
52         return 0;
53     int *x1 = lower_bound(i_buf + xb[v], i_buf + xe[v], l0);
54     int *x2 = upper_bound(i_buf + xb[v], i_buf + xe[v], r0);
55     return x2 - x1;
56 }
57 
58 int querya(int l0, int r0, int p, int k) {
59     int ans = 0;
60     for (int i = k; i <= maxv; i += p)
61         ans += querys(i, l0, r0);
62     return ans;
63 }
64 
65 int main() {
66     freopen("light.in", "r", stdin);
67     freopen("light.out", "w", stdout);
68 
69     scanf("%d%d", &n, &m);
70     tib = 0;
71     for (int i = 1; i <= n; ++ i)
72         scanf("%d", a + i);
73     pre();
74     while (m --) {
75         int l, r, p, k;
76         scanf("%d%d%d%d", &l, &r, &p, &k);
77         if (p <= bsz)
78             printf("%d\n", queryb(l, r, p, k));
79         else
80             printf("%d\n", querya(l, r, p, k));
81     }
82 }

正解