0%

一元多项式的乘法与加法运算(20 分)

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
//初版18分,
/*

测试点 提示 结果 耗时 内存
0 sample换个数字 答案正确 3 ms 244KB
1 同类项合并时有抵消 答案正确 2 ms 240KB
2 系数和指数取上限,结果有零多项式 答案正确 2 ms 244KB
3 输入有零多项式和常数多项式 段错误 2 ms 240KB
*/
#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;

typedef struct {
int zhishu;
int xishu;
}danxiang;

bool cmp(danxiang a,danxiang b)
{
return a.zhishu>b.zhishu;
}

int main()
{
vector<danxiang> a,b,jiafa,chengfa;
int n,zhishu,xishu;
cin>>n;


while(n--)
{
danxiang tmp;
cin>>tmp.xishu>>tmp.zhishu;
a.push_back(tmp);
}
cin>>n;
while(n--)
{
danxiang tmp2;
cin>>tmp2.xishu>>tmp2.zhishu;
b.push_back(tmp2);
}
//for(int i=0;i<a.size();i++)
// cout<<a[i].zhishu<<a[i].xishu;
//乘法

for(int i=0;i<a.size();i++)
{
for(int j=0;j<b.size();j++)
{
danxiang tmp3;
tmp3.xishu=a[i].xishu*b[j].xishu;
tmp3.zhishu=a[i].zhishu+b[j].zhishu;
chengfa.push_back(tmp3);
}
}
//排序+合并同类项
sort(chengfa.begin(),chengfa.end(),cmp);
int tmp;
if(chengfa.size()>1)
{
for(vector<danxiang>::iterator i=chengfa.begin()+1;i!=chengfa.end();i++)
{
if(i->zhishu==(i-1)->zhishu)
{
(i-1)->xishu+=i->xishu;
chengfa.erase(i);
}
}
}




int flag=0;
for(int i=0;i<chengfa.size();i++)
{
if(flag&&chengfa[i].xishu!=0) {
cout << " ";
}
if(chengfa[i].xishu!=0) {
cout << chengfa[i].xishu << " " << chengfa[i].zhishu;
flag = 1;
}
}


if(flag==0)
cout<<"0 0";
cout<<endl;
//加法
for(int i=0;i<a.size();i++)
jiafa.push_back(a[i]);
for(int i=0;i<b.size();i++)
jiafa.push_back(b[i]);

int cnt=0;
if(jiafa.size()>1)
{
for(vector<danxiang>::iterator i=jiafa.begin();i!=jiafa.end()-1;i++)
{
for(vector<danxiang>::iterator j=i+1;j!=jiafa.end();j++)
{
if(i->zhishu==j->zhishu)
{
i->xishu+=j->xishu;
cnt++;
jiafa.erase(j);
}
}
}
}

sort(jiafa.begin(),jiafa.end(),cmp);


flag=0;
for(int i=0;i<jiafa.size();i++)
{
if(flag&&jiafa[i].xishu!=0) {
cout<< " ";
}
if(jiafa[i].xishu!=0)
{
cout << jiafa[i].xishu << " " << jiafa[i].zhishu;
flag=1;
}
}

if(flag==0)
cout<<"0 0";




return 0;

}

终结版

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;

typedef struct {
int zhishu;
int xishu;
}danxiang;

bool cmp(danxiang a,danxiang b)
{
return a.zhishu>b.zhishu;
}

int main()
{
vector<danxiang> a,b,jiafa,chengfa;
int n,zhishu,xishu;
cin>>n;


while(n--)
{
danxiang tmp;
cin>>tmp.xishu>>tmp.zhishu;
a.push_back(tmp);
}
cin>>n;
while(n--)
{
danxiang tmp2;
cin>>tmp2.xishu>>tmp2.zhishu;
b.push_back(tmp2);
}
//for(int i=0;i<a.size();i++)
// cout<<a[i].zhishu<<a[i].xishu;
//乘法

for(int i=0;i<a.size();i++)
{
for(int j=0;j<b.size();j++)
{
danxiang tmp3;
tmp3.xishu=a[i].xishu*b[j].xishu;
tmp3.zhishu=a[i].zhishu+b[j].zhishu;
chengfa.push_back(tmp3);
}
}
//排序+合并同类项
sort(chengfa.begin(),chengfa.end(),cmp);
int tmp;
if(chengfa.size()>1)
{
for(vector<danxiang>::iterator i=chengfa.begin()+1;i!=chengfa.end();i++)
{
if(i->zhishu==(i-1)->zhishu)
{
(i-1)->xishu+=i->xishu;
i->xishu=0;
}
}
}




int flag=0;
for(int i=0;i<chengfa.size();i++)
{
if(flag&&chengfa[i].xishu!=0) {
cout << " ";
}
if(chengfa[i].xishu!=0) {
cout << chengfa[i].xishu << " " << chengfa[i].zhishu;
flag = 1;
}
}


if(flag==0)
cout<<"0 0";
cout<<endl;
//加法
for(int i=0;i<a.size();i++)
jiafa.push_back(a[i]);
for(int i=0;i<b.size();i++)
jiafa.push_back(b[i]);

if(jiafa.size()>1)
{
for(vector<danxiang>::iterator i=jiafa.begin();i!=jiafa.end()-1;i++)
{
for(vector<danxiang>::iterator j=i+1;j!=jiafa.end();j++)
{
if(i->zhishu==j->zhishu)
{
i->xishu+=j->xishu;
j->xishu=0;
}
}
}
}

sort(jiafa.begin(),jiafa.end(),cmp);


flag=0;
for(int i=0;i<jiafa.size();i++)
{
if(flag&&jiafa[i].xishu!=0) {
cout<< " ";
}
if(jiafa[i].xishu!=0)
{
cout << jiafa[i].xishu << " " << jiafa[i].zhishu;
flag=1;
}
}

if(flag==0)
cout<<"0 0";




return 0;

}
## 段错误的原因总结 要理解段错误必须了解vector::erase()函数的使用方法,这个函数删除一个元素,并且反而下一个元素的迭代器。但是注意,他的参数就是一个迭代器,所以他删除元素之后,直接修改了迭代器,造成了vector访问越界 ,产生segmentfault错误。
可以通过下面的代码理解一下:
#include #include using namespace std;

int main()
{
    vector<int> a;
    for(int i=0;i<10;i++)
        a.push_back(i);
    /*
    for(vector<int>::iterator i=a.begin();i!=a.end();i++)
        cout<<"地址: "<<&i<<" "<<"数值: "<<*i<<endl;
        */
    for(vector<int>::iterator i=a.begin();i!=a.end();i++)
    {
        cout<<"地址: "<<&i<<" "<<"数值: "<<*i<<endl;
        a.erase(i);
        cout<<"使用erase之后: "<<&i<<" "<<*i<<endl;
    }
    cout<<"删除之后的"<<endl;
    for(vector<int>::iterator i=a.begin();i!=a.end();i++)
        cout<<*i<<endl;
}

ps:可以看到迭代器i的地址在一个循环中始终不变,所以说i作为一个迭代器和指针类似,但是并不是指针,可能是他的数据区才用来指向迭代数据的地址

阅读全文 »

linux使用总结


使用了最流行的linux Mint系统18.2   ## 使用问题: * 显卡兼容问题,神船的显卡跑windowsP事没有,但是使用linux,蛋疼地要死要活的,要不就是卡屏,要不就是死机,还好找到了linux Mint系统,成功上了linux的大船。 * 社交软件。qq上经常哟嗯的qq,微信在linux上都没有,因为腾讯在12年就停止了对linux版本qq的维护,并且禁止低版本qq登陆,但是仍然有解决办法,WineQQ,或者是github学照Mojo:qq(终端qq,高端大气上档次) * 许多问题不熟悉,无法修改。解决方法就是使用google搜索引擎,不要使用百度就可以解决了

chrominum无法正常现实embed标签

flash没安装??但是部分网页的flash是可以正常显示的,chrome://flash,发现flash没有安装,但是安装了几次。。。。完全gg,最后找到了解决方法
sudo apt-get install pepperflashplugin-nonfree

chrominum指定协议打开应用程序

阅读全文 »

用python写网络爬虫笔记

文档(python2.7):
os库的使用
python re正则的使用
requests库
BeautifulSoup
scrapy
pickle序列化模块
pickle官方文档 datetime

第一章:

检查robots.txt 和sitemap确定网站规格
尽可能不要去爬取那些rotbots禁止的文件夹,否则有可能被服务器封ip
可以利用网站地图对网站进行爬取
数百个网页的站点可以使用串行下载,如果是数百万个网页需要用到分布式
估算网站大小可以使用google爬虫的结果 http://google.com/advanced_search site 在域名后面加上url路径可以对结果进行进一步过滤
识别网站所用技术builtwith模块

1
2
import builtwith   
builtwith.parse('http://www.baidu.com')
whois协议查询域名的注册者,https://pypi.python.org/pypi/python-whois #python-whois Google的域名常常会阻断网络爬虫................... 1.4编写第一个网络爬虫 1.爬取 爬地图 遍历网页数据库id 追踪网页链接 换书了

python网络数据采集

阅读全文 »

xss学习笔记

挖掘

触点

orign

1.inline-javascript 2.attribute
普通属性:oncut(用户剪切元素时触发ctrl+x触发)=alert(1) autofocus/onfocus(点一下)=alert(1)// nerror=alert(1)// onclick=alert(1)//
事件属性:使用html实体编码闭合js delfeedbak('&apos;)alert(1)//') &apos是个'
vbscript(ie) <![if<iframe/onload=vbs:alert[:]>
<img language=vbs src=<bonerror=alert#1/1#>
<script language=vbs></script><img src=xx:xonerror="::alert+'1'::"

阅读全文 »

[TOC] # 数据隐藏技术揭秘笔记 ## 第一章 密写术的发展史 1.凯撒密码
2.摩斯密码
3.维吉尼亚密码 可以通过分析频率来破解,语言特征

1
2
3
from pycipher import Vigenere as vs
vs("密钥").encipher("明文") #加密
vs("密钥").decipher("密文") #解密
online 思科的密码就是维吉尼亚的变种,所以有在线破解工具
4. 移位密码 5. 替换密码 des标准加密 原文分组,每组8个字母 16轮移位和替换操作


隐写
1.卡尔达诺栅格码 spam minic
2.隐形墨水 缩影术 打印机跟踪点(interesting) eff打印机跟踪点 可以使用跟踪点解密工具解密
3.水印: >数字水印,维护数字媒体文件的版权和防伪

第二章 数据隐藏简单练习4则

word可以通过编辑属性插入作者名称,公司名称,关键词,标签和其他数据,这些数据叫做元数据

阅读全文 »

leetcode题解实践笔记

Pascal's Triangle

帕斯卡三角,当然也叫杨辉三角,某一行某一列的元素等于上一行相邻两个元素的和,所以说找规律就成了,但是重点在与vector的初始化容量,否则就会报错,提示你reference binding to null pointer of type 'struct value_type'

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

class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>>res;
res.resize(numRows);
int temp;
for(int i=0;i<numRows;i++)
{
for(int j=0;j<i+1;j++)
{
if(j==0||j==i)
{
temp=1;
res[i].push_back(temp);
}

else if(i>=1&&j>=1)
{
temp=res[i-1][j]+res[i-1][j-1];
res[i].push_back(temp);
}

}
}
return res;
}
};

运行时间3ms,看了大佬的做法,0ms,我的使用了太多的判断语句,耗时会变得很多..........

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
class Solution {
public:
vector<vector<int>> generate(int numRows) {
vector<vector<int>>res;
if(numRows==0)
return res;

res.resize(numRows);
for(int i=0;i<numRows;i++)
res[i].resize(i+1);
res[0][0]=1;
for(int i=0;i<numRows;i++)
{
res[i][0]=1;
res[i][i]=1;
}
for(int i=2;i<numRows;i++)
{
for(int j=1;j<i;j++)
res[i][j]=res[i-1][j]+res[i-1][j-1];
}

return res;
}
};
但是感觉题解上的答案更节省时间,因为只用了一个二次循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public:
vector<vector<int> > generate(int numRows) {
vector<vector<int> > vals;
vals.resize(numRows);
for(int i = 0; i < numRows; i++) {
vals[i].resize(i + 1);
vals[i][0] = 1;
vals[i][vals[i].size() - 1] = 1;
for(int j = 1; j < vals[i].size() - 1; j++) {
vals[i][j] = vals[i - 1][j - 1] + vals[i - 1][j];
}
}
return vals;
}
};
阅读全文 »

Like a Boss!

题目给了一个有ascii字符组成的图案,仔细观察应该可以发现除了M和回车还有:还有.等无意义的字符,使用工具去除就可以得到答案
wp中给的答案是tr -d 'M.\: \n<<likeaboss.txt,我一开始以为后面的字符串是正则表达式,后来发现并不是,只是一个匹配的规则,只要输入tr --help就可以查看了
但是自己查看文档发现中':'前面的的''是不必要的,因为':'并不需要转义
附上两份文档英文版中文版

primitive encryption

Hi Hacker

What about a time travel ? ^^ Your mission is to be very observative, sometimes a theory start from a supposition. Decrypt this and you will get your flag : i KTAX ZTRTRTC SuB AKXy KXlp you GiRViRF youN GlTF TRV iA'C FFAKTAwTCXTCy To validate the challenge enter : Bugs_Bunny{your_flag_uppercase} By Mabrouki Fakhri MrGoOD

阅读全文 »

hackburger地址 # Warmup(10) 打开题目出现一个ping的工具,自然想到命令注入,尝试使用分号作为命令的分隔符试试
payload:127.0.0.1;ls
显示结果出现了当前目录的两个文件一个是flag.php另一个是index.php,使用cat命令查看一下
127.0.0.1;cat flag.php
查看网页源文件就可以看到flag了,ps:这个题挺简单的,但是我做了很久,因为我以为回显的网页源码一定会显示在网页上面,结果flag.php的内容是一句注释.....................
# File search 文件搜索,一开始以为sql注入,搞了半天放弃了,后来听大佬说这个搜索框还可以搜索文件的内容,思考半天无果,后来又听了以为大佬的思路,开始动手,由于代码能力比较弱...........所以采取了最暴力最简单的做法,burpsuite暴力枚举(手动斜眼笑)
首先测试所有可打印字符,只要结果中出现flag.txt,那么就证明文件中含有这个字符,最后测试下来是有35个字符,猜想组合有多少种?,于是就想用全排列,但是想想还是算了,因为生成这样的组合需要耗尽我一生的时间zz,所以有思考了一会,觉得可以这样搞,首先用这35个字符排列组合,测试出flag.txt中两个相邻的字符,最后找出两百多个,然后再用两个为一组,跑出四个字符,再跑八个,每次x2,payload的规模越来越小,,等到字符变少的时候,我们可以发现其实这个搜索不区分大小写,所以可以把大写去掉,缩小一半规模,再推理出最长的字符。这时候再用x2就无效了,因为x2字符的长度会过大,这时候可以用刚才跑出的1个字符,或是两个字符,等等,在最长字符的后面添加测试,最后得到flag

shadowsocks服务器的搭建

最近想要做一些关于netcat命令的题目,但是苦于学校的网络是内网,所以我的netcat命令无法绑定ip,所以只能使用vps,所以我决定使用vps来做。
首先要有python环境,其次要有pip
sudo apt-get install python-gevent python-pip
sudo pip install shadowsocks
为了支持某些密码的加密方式可能需要安装apt-get install python-m2crypto
下面是shadowsocks的使用方法:ssserver --help
usage: ssserver [OPTION]... A fast tunnel proxy that helps you bypass firewalls.

    You can supply configurations via either config file or command line arguments.
    
    Proxy options:
      -c CONFIG              path to config file
      -s SERVER_ADDR         server address, default: 0.0.0.0
      -p SERVER_PORT         server port, default: 8388
      -k PASSWORD            password
      -m METHOD              encryption method, default: aes-256-cfb
      -t TIMEOUT             timeout in seconds, default: 300
      --fast-open            use TCP_FASTOPEN, requires Linux 3.7+
      --workers WORKERS      number of workers, available on Unix/Linux
      --forbidden-ip IPLIST  comma seperated IP list forbidden to connect
      --manager-address ADDR optional server manager UDP address, see wiki
    
    General options:
      -h, --help             show this help message and exit
      -d start/stop/restart  daemon mode
      --pid-file PID_FILE    pid file for daemon mode
      --log-file LOG_FILE    log file for daemon mode
      --user USER            username to run as
      -v, -vv                verbose mode
      -q, -qq                quiet mode, only show warnings/errors
      --version              show version information
    
    Online help: <https://github.com/shadowsocks/shadowsocks>

然后就可以运行了,但是为了方便我们可以把配置保存在一个json配置文件里面,或者直接像下面一样运行
`sudo ssserver -s ip地址 -p 服务器端口 -k 密码 -m 加密方式 -t 超时时间 -d start 然后就可以后台运行了,必须要用root权限,否则无法后台运行
创建一个json配置文件:

    {
        "server":“*.*.*.*",
        "server_port":1-65535,    #1-1000是系统常用端口,所以你懂得
        "password":"password",
        "method":"aes-256-cfb",  #加密方法,可选择"bf-cfb","aes-256-cfb","des-cfb","rc4",等等。默认是一种不安全的加密,推荐用"aes-256-cfb"
        "timeout":600
        "local_port":1080    #通常shadowsocks客户端的默认端口是1080
    }    
阅读全文 »