m
e
m
s
e
t
(
f
,
1
,
s
i
z
e
o
f
(
f
)
)
memset(f,1,sizeof(f))
memset(f,1,sizeof(f))
特别注意这样不能把
f
f
f初始化为1，应该用循环初始化
m e m s e t ( f , 0 , s i z e o f ( f ) ) memset(f,0,sizeof(f)) memset(f,0,sizeof(f))
初始化为-1m e m s e t ( f , − 1 , s i z e o f ( − 1 ) ) memset(f,-1,sizeof(-1)) memset(f,−1,sizeof(−1))
初始化为正无穷
m
e
m
s
e
t
(
f
,
0
x
3
f
,
s
i
z
e
o
f
(
f
)
)
memset(f,0x3f,sizeof(f))
memset(f,0x3f,sizeof(f))
f中每个数都是
0
x
3
f
3
f
3
f
3
f
0x3f3f3f3f
0x3f3f3f3f
m
e
m
s
e
t
(
f
,
−
0
x
3
f
,
s
i
z
e
o
f
(
f
)
)
memset(f,-0x3f,sizeof(f))
memset(f,−0x3f,sizeof(f))
特别注意与初始化正无穷不同: 每个数都不是
−
0
x
3
f
3
f
3
f
3
f
-0x3f3f3f3f
−0x3f3f3f3f，而是另一个较大的负数
int main()
{
int x=178;
cout<(x)<
求一个二进制数的子集（不包括本身和全
0
0
0 ）
#include
using namespace std;
int main()
{
int i = 7;
cout << "i=" << bitset<4>(i) << endl;
for(int j = i - 1; j; j = (j - 1) & i)
cout << bitset<3>(j) << endl;
return 0;
}
输出为
i=0111
110
101
100
011
010
001
1-n中的质数个数
大约是
n
l
n
n
frac{n}{lnn}
lnnn个
g
c
d
(
a
,
b
)
=
p
gcd(a,b)=p
gcd(a,b)=p，(
p
p
p 是质数)
g
c
d
(
a
,
b
)
=
p
gcd(a,b)=p
gcd(a,b)=p 等价于
g
c
d
(
a
p
,
b
p
)
=
1
gcd(frac{a}{p},frac{b}{p})=1
gcd(pa,pb)=1，之后就能用欧拉函数了
lower_bound与upper_bound
转载于这篇博客
在从小到大的排序数组中
l
o
w
e
r
_
b
o
u
n
d
(
b
e
g
i
n
,
e
n
d
,
n
u
m
)
，
从
数
组
的
b
e
g
i
n
位
置
到
lower_bound(begin,end,num)，从数组的 begin 位置到
lower_bound(begin,end,num)，从数组的begin位置到
e
n
d
−
1
end-1
end−1
位
置
二
分
查
找
位置二分查找
位置二分查找
第
一
个
大
于
等
于
n
u
m
第一个大于等于num
第一个大于等于num
的
数
，
返
回
该
数
字
的
地
址
，
不
存
在
则
返
回
e
n
d
。
通
过
返
回
地
址
减
去
起
始
地
址
（
不
一
定
是
b
e
g
i
n
）
，
就
能
得
到
该
数
字
在
数
组
中
的
下
标
的数，返回该数字的地址，不存在则返回end。通过返回地址减去起始地址（不一定是begin），就能得到该数字在数组中的下标
的数，返回该数字的地址，不存在则返回end。通过返回地址减去起始地址（不一定是begin），就能得到该数字在数组中的下标
u
p
p
e
r
_
b
o
u
n
d
(
b
e
g
i
n
,
e
n
d
,
n
u
m
)
,
从
数
组
的
b
e
g
i
n
位
置
到
upper_bound(begin,end,num),从数组的begin位置到
upper_bound(begin,end,num),从数组的begin位置到
e
n
d
−
1
end-1
end−1
位
置
，
二
分
查
找
位置，二分查找
位置，二分查找
第
一
个
大
于
n
u
m
第一个大于num
第一个大于num
的
数
的数
的数，
返
回
该
数
字
的
地
址
，
不
存
在
则
返
回
e
n
d
。
通
过
返
回
地
址
减
去
起
始
地
址
（
不
一
定
是
b
e
g
i
n
）
，
就
能
得
到
该
数
字
在
数
组
中
的
下
标
返回该数字的地址，不存在则返回end。通过返回地址减去起始地址（不一定是begin），就能得到该数字在数组中的下标
返回该数字的地址，不存在则返回end。通过返回地址减去起始地址（不一定是begin），就能得到该数字在数组中的下标
在从大到小的排序数组中，重载
l
o
w
e
r
b
o
u
n
d
和
u
p
p
e
r
b
o
u
n
d
lower_bound和upper_bound
lowerbound和upperbound
l
o
w
e
r
b
o
u
n
d
(
b
e
g
i
n
,
e
n
d
,
n
u
m
,
lower_bound(begin,end,num,
lowerbound(begin,end,num,
g
r
e
a
t
e
r
<
i
n
t
>
(
)
greater()
greater()
)
:
从
数
组
的
b
e
g
i
n
位
置
到
):从数组的begin位置到
):从数组的begin位置到
e
n
d
−
1
end-1
end−1
位
置
，
二
分
查
找
位置，二分查找
位置，二分查找
第
一
个
小
于
等
于
n
u
m
第一个小于等于num
第一个小于等于num
的
数
字
，
找
到
返
回
该
数
字
的
地
址
，
不
存
在
则
返
回
e
n
d
。
通
过
返
回
的
地
址
减
去
起
始
的
地
址
（
不
一
定
是
b
e
g
i
n
）
，
就
能
得
到
该
数
字
在
数
组
中
的
下
标
的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始的地址（不一定是begin），就能得到该数字在数组中的下标
的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始的地址（不一定是begin），就能得到该数字在数组中的下标
u
p
p
e
r
_
b
o
u
n
d
(
b
e
g
i
n
,
e
n
d
,
n
u
m
,
upper_bound(begin,end,num,
upper_bound(begin,end,num,
g
r
e
a
t
e
r
<
i
n
t
>
(
)
greater()
greater()
)
:
从
数
组
的
b
e
g
i
n
位
置
到
):从数组的begin位置到
):从数组的begin位置到
e
n
d
−
1
end-1
end−1
位
置
，
二
分
查
找
位置，二分查找
位置，二分查找
第
一
个
小
于
n
u
m
第一个小于num
第一个小于num
的
数
字
，
找
到
返
回
该
数
字
的
地
址
，
不
存
在
则
返
回
e
n
d
，
通
过
返
回
的
地
址
减
去
起
始
的
地
址
（
不
一
定
是
b
e
g
i
n
）
，
就
能
得
到
该
数
字
在
数
组
中
的
下
标
的数字，找到返回该数字的地址，不存在则返回end，通过返回的地址减去起始的地址（不一定是begin），就能得到该数字在数组中的下标
的数字，找到返回该数字的地址，不存在则返回end，通过返回的地址减去起始的地址（不一定是begin），就能得到该数字在数组中的下标
