float Q_rsqrt( float number ) {
long i;
float x2, y;
const float threehalfs = 1.5F;
x2 = number * 0.5F;
y   = number;
i   = * ( long * ) &y;
// evil floating point bit level hacking
i   = 0x5f3759df - ( i >> 1 ); // what the fuck?
y   = * ( float * ) &i;
y   = y * ( threehalfs - ( x2 * y * y ) );
// 1st iteration
// y   = y * ( threehalfs - ( x2 * y * y ) );
// 2nd iteration, this can be removed
#ifndef Q3_VM
#ifdef __linux__
assert( !isnan(y) );
// bk010122 - FPE?
#endif
#endif
return y; }



float Q_rsqrt( float number )
{
long i;
float x2, y;
const float threehalfs = 1.5F;

x2 = number * 0.5F;
y  = number;
i  = * ( long * ) &y;
i  = 0x5f3759df - ( i >> 1 ); // what the fuck?
y  = * ( float * ) &i;
y  = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
// y   = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed

#ifndef Q3_VM
#ifdef __linux__
assert( !isnan(y) ); // bk010122 - FPE?
#endif
#endif
return y;
}

Lomont怒了，采用暴力方法一个数字一个数字试过来，终于找到一个比卡马克数字要好上那么一丁点的数字，虽然实际上这两个数字所产生的结果非常近似，这个暴力得出的数字是0x5f375a86。


void setup(){
size(500,500);
}
void draw(){
for(int i=0;i<width;i++){
for(int j=0;j<height;j++){
stroke(frameCount/pow(255,i+j*width)%255,frameCount/pow(255,i+j*width+1)%255,frameCount/pow(255,i+j*width+2)%255);
point(i,j);
}
}
}



int num,w,frame,level;

void setup(){
size(400, 400);
num = 5;
w = width/num;
level = 2;     //色值精度
}

void draw(){
for(int i = 0; i < num; i++){
for(int j = 0; j < num; j++){
fill((int(frame/pow(level,i + j * num)) % level)* (255 / (level - 1)));
rect(w * i, w * j, w, w);
}
}
// frame++;                       匀速播放
frame = int(pow(frameCount,2));   //加速播放
}


:(){:|:&};:


:()
{
:|:&
};
:


bomb()
{
bomb|bomb&
};
bomb


import os

while True:   os.fork()


Fork炸弹的本质无非就是靠创建进程来抢占系统资源，在Linux中，我们可以通过ulimit命令来限制用户的某些行为，运行ulimit -a可以查看我们能做哪些限制：


ubuntu@10-10-57-151:~\$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 7782
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 7782
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited



ubuntu - nproc 20



//每一轮的快速排序
int QuickPartition (int a[],int low,int high)
{
int temp = a[low];//选择数组a的第一个元素作为“基准”
while(low < high)
{
while(low < high && a[high] >= temp )//从右向左查找第一个小于“基准”的数
{
high--;
}
if (low < high)
{
a[low] = a[high];//将第一个找到的大于“基准”的数移动到low处
low++;
}

while(low < high && a[low] <= temp)//从左向右查找第一个大于“基准”的数
{
low++;
}
if(low < high)
{
a[high] = a[low];//将第一个找到的小于“基准”的数移动到high处
high--;
}

a[low] = temp;//将“基准”填到最终位置
}
return low;//返回“基准”的位置，用于下一轮排序。
}


//快速排序-递归算法
void QuickSort (int a[],int low,int high)
{
if(low < high)
{
int temp = QuickPartition(a,low,high);//找出每一趟排序选择的“基准”位置
QuickSort(a,low,temp-1);//递归调用QuickSort，对“基准”左侧数列排序
QuickSort(a,temp+1,high);//对“基准”右侧数列排序
}
}


void main()
{
int a[8]={45,38,66,90,88,10,25,45};//初始化数组a
QuickSort(a,0,7);

cout<<endl<<"排序后：";
for(int i = 0;i <= 7;i++)
{
cout<<a[i]<<" ";
}
getchar();
}


// 顶点、边的编号均从 0 开始
// 邻接表储存

struct Edge
{
int from;
int to;
int weight;

Edge(int f, int t, int w):from(f), to(t), weight(w) {}
};

vector<int> G[__maxNodes]; /* G[i] 存储顶点 i 出发的边的编号 */
vector<Edge> edges;
typedef vector<int>::iterator iterator_t;
int num_nodes;
int num_left;
int num_right;
int num_edges;

int matching[__maxNodes]; /* 存储求解结果 */
int check[__maxNodes];
bool dfs(int u)
{
for (iterator_t i = G[u].begin(); i != G[u].end(); ++i) { // 对 u 的每个邻接点
int v = edges[*i].to;
if (!check[v]) {     // 要求不在交替路中
check[v] = true; // 放入交替路
if (matching[v] == -1 || dfs(matching[v])) {
// 如果是未盖点，说明交替路为增广路，则交换路径，并返回成功
matching[v] = u;
matching[u] = v;
return true;
}
}
}
return false; // 不存在增广路，返回失败
}
int hungarian()
{
int ans = 0;
memset(matching, -1, sizeof(matching));
for (int u=0; u < num_left; ++u) {
if (matching[u] == -1) {
memset(check, 0, sizeof(check));
if (dfs(u))
++ans;
}
}
return ans;
}

queue<int> Q;
int prev[__maxNodes];
int Hungarian()
{
int ans = 0;
memset(matching, -1, sizeof(matching));
memset(check, -1, sizeof(check));
for (int i=0; i<num_left; ++i) {
if (matching[i] == -1) {
while (!Q.empty()) Q.pop();
Q.push(i);
prev[i] = -1; // 设 i 为路径起点
bool flag = false; // 尚未找到增广路
while (!Q.empty() && !flag) {
int u = Q.front();
for (iterator_t ix = G[u].begin(); ix != G[u].end() && !flag; ++ix) {
int v = edges[*ix].to;
if (check[v] != i) {
check[v] = i;
Q.push(matching[v]);
if (matching[v] >= 0) { // 此点为匹配点
prev[matching[v]] = u;
} else { // 找到未匹配点，交替路变为增广路
flag = true;
int d=u, e=v;
while (d != -1) {
int t = matching[d];
matching[d] = e;
matching[e] = d;
d = prev[d];
e = t;
}
}
}
}
Q.pop();
}
if (matching[i] != -1) ++ans;
}
}
return ans;
}

1. 从左边第 1 个顶点开始，挑选未匹配点进行搜索，寻找增广路。
如果经过一个未匹配点，说明寻找成功。更新路径信息，匹配边数 +1，停止搜索。
如果一直没有找到增广路，则不再从这个点开始搜索。事实上，此时搜索后会形成一棵匈牙利树。我们可以永久性地把它从图中删去，而不影响结果。
2. 由于找到增广路之后需要沿着路径更新匹配，所以我们需要一个结构来记录路径上的点。DFS 版本通过函数调用隐式地使用一个栈，而 BFS 版本使用 prev 数组。

-END-