TCP - IP 三次确认。
发送方发出消息-(渴望建立连接)

接受方收到消息-(不予建立

NO ACK
NO ACK
NO ACK

超时未响应-(建立连接失败。

微信图片_20220405105843.jpg

no seek

1.在电脑上打开抢购疫苗.exe(可能会被爆病毒)
image.png
2.在微信端打开秒苗小程序
.36b36dab5cc8966e7dcabe42739d24b.png
3.使用Fidder抓取小程序的数据包1e252f0bb7f5f6b4132c9ba06281ead.png

4.
填写cookie和TKaf4d85c48b0f26cea24b21ca35c32d0.png

5.选择接种人2be3b7b4b91a0f81e1601fd9695b458.png
6.刷新疫苗列表ab1848518c0b54f291c58339731f0de.png
7.在秒杀开始前,点击开始,就可以挂着了。

b81629ad470e50946a527272813925a.png
需要注意的是:电脑时间应该和北京时间一致,
登录秒苗小程序的时间应该在秒杀前一小时内,否则COOKIE会失效

一.使用Fiddler等抓包工具抓取约苗小程序请求header

http://www.winwin7.com/soft/13111.html
网站下载Fiddler
抓取 tk ,cookie

use

  • hpv4g.py执行秒杀 -h可选参数

    • 位置参数(固定必传参数)

      • tk 抓包获取的tk数据
      • cookie 抓包获取的cookie数据
    • 可选参数

      • -mw[--max_workers] 最大秒杀线程数(默认使用min(32, cpu_count + 4))
      • -rc[--region_code] 指定区域编码(約苗使用4位行政区域CODE 默认成都:5101)
      • -reload_cache 当前城市所有可秒杀(即5S内可开始秒杀)疫苗一起秒杀。 因此秒杀前会缓存当前城市可秒杀疫苗列表到 cache/vaccines_xxx.json中。真正执行秒杀时从本地获取疫苗列表(减少受Server端降级策略影响)。 -reload_cache参数用于指定本次秒杀需要更新缓存列表(场景:第一天执行秒杀后缓存了数据,第二天再次秒杀时需要重新加载最新疫苗列表一次)
      • -sp[--single_point]只秒杀单个疫苗[即所有线程秒杀同一个疫苗] 默认不开启该参数则所有线程分配秒杀所有可秒杀疫苗
      • -pi[(--proxy_ip)] 开启IP代理池 默认不开启 测试发现使用IP代理池后 对服务端访问频率限制并没有太明显的效果(仍然大量的请求502、操作频繁...), 初步判断服务端是用 【帐号】 维度的限制(有条件可以使用多个微信帐号同时秒杀)
      • --log 日志级别 默认WARNING
  • cache/vaccines.json文件# tkstring cookiestring 为抓包得到的tk cookie scan_vaccine.py tkstring cookiestring
  • 如果是运行 从成都市金牛区妇幼保健院服务号中抢购
    命令:JiuJia jinniu --config=/path/to/your/config.yml
  • 如果是运行 从约苗中抢购
    命令:JiuJia yuemiao --config=/path/to/your/config.yml

  • tkstring cookiestring 为抓包得到的tk

  • cookie scan_vaccine.py tkstring cookiestring
  • 目前只能做到16线程同时抢购
  • 99932751-f9d72100-2d93-11eb-8840-1110e0be3136(1).png

去了春熙路,发现那么多好的东西,自己想得到。-- 打起劲来,自己现在还没有什么能给给予别人的。理清自己的思绪吧。全力准备复试吧。无论成功与否,该规划一下自己的人生了。你都20多岁了。给自己一个承诺吧。
毕业前瘦到140
攒钱买车
(考上研了骑行去西藏)
努力提升自己吧。
一个月解决一本书吧。
三月:算法导论 √
四月:深入理解计算机系统 (并每天完成操作系统部分的编写)(给她表白)
五月:计算机网络自顶而下方法
一无是处却心比天高。
make it better
加强PS ,PR
你要有别人喜欢你的资本。
for yourself .for m

【思考题】

6-1 用插入方法建堆

a) 当输入数组相同时,过程BUILD_MAX_HEAP和BUILD_MAX_HEAP'产生的堆是否总是一样的?是的给出证明;否则给出反例。


n = 9
A = <5 3 17 10 84 19 6 22 9>
BUILD_MAX_HEAP:84 22 19 10 3 17 6 5 9
BUILE_MAX_HEAP':84 22 19 17 10 5 6 3 9
b) 证明:最坏情况下,BUILD_MAX_HEAP'要用⊙(nlgn)时间来建成一个含n个元素的堆。

执行一次MAX_HEAP_INSERT最坏的时间为⊙(logn)。BUILD_MAX_HEAP'中执行了n次,因此复杂度为⊙(nlogn)

template<typename Type>
class CHeap{
private:
    Type *A;
    int heapSize;
    int length;
    inline int left(int x) { return x<<1; }
    inline int right(int x) { return x<<1|1; }
    inline int parent(int x) { return x>>1; }
public:
    CHeap(){}
    CHeap(Type B[],int n) {
        init(B,n);
    }
    void init(Type B[],int n) {
        A = B;
        length = n;
        heapSize = 0;
    }
    void heapSort() {
        buildMaxHeap();
        for (int i=length;i>=2;i--) {
            swap(A[1],A[i]);
            heapSize--;
            maxHeapify(1);
        }
    }
 
    void maxHeapify(int i) {
        int l = left(i);
        int r = right(i);
        int largest = i;
        if (l <= heapSize && A[l] > A[largest]) largest = l;
        if (r <= heapSize && A[r] > A[largest]) largest = r;
        if (largest != i) {
            swap(A[i],A[largest]);
            maxHeapify(largest);
        }
    }
    void maxHeapify_NonRecursive(int i) {
        while (true) {
            int l = left(i);
            int r = right(i);
            int largest = i;
            if (l <= heapSize && A[l] > A[largest]) largest = l;
            if (r <= heapSize && A[r] > A[largest]) largest = r;
            if (largest == i) break;
            swap(A[i],A[largest]);
            i = largest;
        }
    }
    void buildMaxHeap() {
        heapSize = length;
        for (int i=length/2;i>=1;i--) {
            maxHeapify(i);
        }
    }
    Type heapMaximum() {
        return A[1];
    }
    Type heapExtractMax() {
        if (heapSize < 1) return 0;
        int max = A[1];
        A[1] = A[heapSize--];
        maxHeapify(1);
        return max;
    }
    void heapIncreaseKey(int i,Type key) {
        if (key < A[i]) return;
        A[i] = key;
        while (i>1 && A[parent(i)] < A[i]) {
            swap(A[i],A[parent(i)]);
            i = parent(i);
        }
    }
    void maxHeapInsert(Type key) {
        heapSize++;
        A[heapSize] = key;
        heapIncreaseKey(heapSize,key);
    }
    void heapDeleteMax(int i) {
        if (i<1||i>heapSize) return;
        A[i] = A[heapSize--];
        maxHeapify(i);
    }
 
    void minHeapify(int i) {
        int l = left(i);
        int r = right(i);
        int smallest = i;
        if (l <= heapSize && A[l] < A[smallest]) smallest = l;
        if (r <= heapSize && A[r] < A[smallest]) smallest = r;
        if (smallest != i) {
            swap(A[i],A[smallest]);
            minHeapify(smallest);
        }
    }
    void minHeapify_NonRecursive(int i) {
        while (true) {
            int l = left(i);
            int r = right(i);
            int smallest = i;
            if (l <= heapSize && A[l] < A[smallest]) smallest = l;
            if (r <= heapSize && A[r] < A[smallest]) smallest = r;
            if (smallest == i) break;
            swap(A[i],A[smallest]);
            i = smallest;
        }
    }
    void buidMinHeap() {
        heapSize = length;
        for (int i=length/2;i>=1;i--) {
            minHeapify(i);
        }
    }
    Type heapMinimum() {
        return A[1];
    }
    Type heapExtractMin() {
        if (heapSize < 1) return 0;
        int min = A[1];
        A[1] = A[heapSize--];
        minHeapify(1);
        return min;
    }
    void heapDecreaseKey(int i,Type key) {
        if (key > A[i]) return;
        A[i] = key;
        while (i>1 && A[parent(i)] > A[i]) {
            swap(A[i],A[parent(i)]);
            i = parent(i);
        }
    }
    void minHeapInsert(Type key) {
        heapSize++;
        A[heapSize] = key;
        heapDecreaseKey(heapSize,key);
    }
    void heapDeleteMin(int i) {
        if (i<1||i>heapSize) return;
        A[i] = A[heapSize--];
        minHeapify(i);
    }
 };




6-2 对d叉堆的分析

a) 如何在一个数组中表示一个d叉堆?

A[(x-1)d+2]、A[(x-1)d+2+1]...A[(x-1)*d+2+k-1] 表示第i个结点的d叉堆第k个子结点。



b) 含n个元素的d叉堆的高度是多少?

c) 给出d叉堆的EXTRACT_MAX的一个有效实现,并用d和n表示出它的运行时间。

Type heapExtractMax() {<br />        if (heapSize < 1) return 0;<br />        int max = A[1];<br />        A[1] = A[heapSize--];<br />        maxHeapify(1);<br />        return max;<br />    }<br />​<br />

d) 给出d叉堆最大堆的INSERT的一个有效实现,并用d和n表示出它的运行时间。

void maxHeapInsert(Type key) {<br />        heapSize++;<br />        A[heapSize] = key;<br />        heapIncreaseKey(heapSize,key);<br />    }

e) 给出INCREASE_KEY(A,i,k)的一个有效实现,该过程首先执行A[i]=max(A[i],k),并相应地更新d叉最大堆的结构。请用d和n表示出它的运行时间。

void heapIncreaseKey(int i,Type key) {<br />        if (key > A[i]) A[i] = key;<br />        while (i>1 && A[parent(i)] < A[i]) {<br />            swap(A[i],A[parent(i)]);<br />            i = parent(i);<br />        }<br />    }<br />​<br />

d叉堆:

template <typename Type>
class CDHeap{
same:
private:
    Type *A;
    int d;
    int heapSize;
    int length;
    inline int son(int x,int k) { return (x-1)*d+2+k; }
    inline int parent(int x) { return (x-2)/d+1; }
public:
    CDHeap(){}
    CDHeap(Type B[],int n,int dd) {
        init(B,n,dd);
    }
    void init(Type B[],int n,int dd) {
        A = B;
        length = n;
        d = dd;
        heapSize = 0;
    }
    void maxHeapify(int x) {
        int largest = x;
        for (int i=0;i<d;i++) {
            int k = son(x,i);
            if (k <= heapSize && A[k] > A[largest]) largest = k;
        }
        if (largest != x) {
            swap(A[x],A[largest]);
            maxHeapify(largest);
        }
    }
    void buildMaxHeap() {
        heapSize = length;
        for (int i=length/d;i>=1;i--) {
            maxHeapify(i);
        }
    }
    Type heapMaximum() {
        return A[1];
    }
    Type heapExtractMax() {
        if (heapSize < 1) return 0;
        int max = A[1];
        A[1] = A[heapSize--];
        maxHeapify(1);
        return max;
    }
    void heapIncreaseKey(int i,Type key) {
        if (key > A[i]) A[i] = key;
        while (i>1 && A[parent(i)] < A[i]) {
            swap(A[i],A[parent(i)]);
            i = parent(i);
        }
    }
    void maxHeapInsert(Type key) {
        heapSize++;
        A[heapSize] = key;
        heapIncreaseKey(heapSize,key);
    }
    void heapSort() {
        buildMaxHeap();
        for (int i=length;i>=2;i--) {
            swap(A[1],A[i]);
            heapSize--;
            maxHeapify(1);
        }
    }
};

6-3 Young氏矩阵

a) 画一个包含元素{9,16,3,2,4,8,5,14,12}的4X4Young氏矩阵。

b) 讨论一个mXn的Young氏矩阵,如果Y[1,1]=OO,则Y为空;如果Y[m,n]<OO,则Y是满的(包含mXn个元素)。

1、当Y[1,1]=OO时,由Young氏矩阵的性质可知,A[1,1]右侧的元素 >= OO,下侧的元素 >= OO,因此A[1,1]的右侧和下侧均为OO。

对Y[1,2...n]做同样的分析,可知矩阵中所有元素均为OO,表示矩阵中不存在元素。

2、当Y[m,n]<OO时,由Young氏矩阵的性质可知,A[m,n]左侧和上侧元素 <= Am < OO。

对Y[m,1...n-1]做同样的分析,可知矩阵中所有元素均小于OO,矩阵中不存在空位置,所以矩阵是满的。

c) 给出一个在非空mXn的Young氏矩阵上实现EXTRACT_MIN的算法,使其运行时间为O(m+n)。

将存在于(1,1)中的最小元素取出。用OO代替,将OO与右边或下边更小的元素进行交换,直至到达正确的位置。

由于元素只能向右或向下移动,F(i,j) = F(i-1,j) or F(i,j-1)。
令p = n+m,,因此F(p) = F(p-1) + O(1),运行时间为O(m+n)。

    void extractYoungs(int x,int y) {
        int sx = x;
        int sy = y;
        if (x < n && matrix[x+1][y] < matrix[sx][sy]) {
            sx = x + 1;
            sy = y;
        }
        if (y < m && matrix[x][y+1] < matrix[sx][sy]) {
            sx = x;
            sy = y + 1;
        }
        if (sx != x || sy != y) {
            swap(matrix[x][y],matrix[sx][sy]);
            extractYoungs(sx,sy);
        }
    }
    int extractMin() {
        int ret = matrix[1][1];
        matrix[1][1] = INF;
        extractYoungs(1,1);
        return ret;
    }


d) 说明如何在O(m+n)的时间内,将一个新元素插入到一个未满的 mXn Young氏矩阵中。

将元素替换掉矩阵中最大的元素An,循环将其与左侧或上侧更大的元素交换,维护矩阵性质。

void insertYoungs(int x,int y) {
        int lx = x;
        int ly = y;
        if (x > 1 && matrix[x-1][y] > matrix[lx][ly] ) {
            lx = x - 1;
            ly = y;
        }
        if (y > 1 && matrix[x][y-1] > matrix[lx][ly]) {
            lx = x;
            ly = y - 1;
        }
        if (lx != x || ly != y) {
            swap(matrix[x][y],matrix[lx][ly]);
            insertYoungs(lx,ly);
        }
    }
    void insert(int x) {
        if (matrix[n][m]!=INF) return;
        matrix[n][m]=x;
        insertYoungs(n,m);
    }
<br />

e)在不用其他排序算法帮助的情况下,说明利用 nXn Young氏矩阵对n^2个数排序的运行时间为O(n^3)。

将n^2个数插入矩阵:O(n+n)*O(n^2) = O(n^3)

取出矩阵中的最小元素n^2次:O(n+n)*O(n^2) = O(n^3)

因此排序运行时间为 O(2*n^3) = O(n^3)



f) 给出一个运行时间为O(m+n)的算法,来决定一个给定的数是否存在于一个给定的 mXn Young氏矩阵内。


  pair<int,int> find(int c) {
        int x = 1,y = m;
        while (x <= n && y >= 1) {
            if (matrix[x][y] == c) return make_pair(x,y);
            if (matrix[x][y] < c) x++;
            if (matrix[x][y] > c) y--;
        }
        return make_pair(0,0);
    }




Young氏矩阵完整代码:


const int MAXN = 100;
const int INF = 0x3f3f3f3f;
class CYoungs{
private:
    int n,m;
    int matrix[MAXN][MAXN];
    void extractYoungs(int x,int y) {
        int sx = x;
        int sy = y;
        if (x < n && matrix[x+1][y] < matrix[sx][sy]) {
            sx = x + 1;
            sy = y;
        }
        if (y < m && matrix[x][y+1] < matrix[sx][sy]) {
            sx = x;
            sy = y + 1;
        }
        if (sx != x || sy != y) {
            swap(matrix[x][y],matrix[sx][sy]);
            extractYoungs(sx,sy);
        }
    }
    void insertYoungs(int x,int y) {
        int lx = x;
        int ly = y;
        if (x > 1 && matrix[x-1][y] > matrix[lx][ly] ) {
            lx = x - 1;
            ly = y;
        }
        if (y > 1 && matrix[x][y-1] > matrix[lx][ly]) {
            lx = x;
            ly = y - 1;
        }
        if (lx != x || ly != y) {
            swap(matrix[x][y],matrix[lx][ly]);
            insertYoungs(lx,ly);
        }
    }
public:
    CYoungs() {}
    void init(int a,int b) {
        n = a;
        m = b;
        memset(matrix,INF,sizeof matrix);
    }
    int extractMin() {
        int ret = matrix[1][1];
        matrix[1][1] = INF;
        extractYoungs(1,1);
        return ret;
    }
    void insert(int x) {
        if (matrix[n][m]!=INF) return;
        matrix[n][m]=x;
        insertYoungs(n,m);
    }
    pair<int,int> find(int c) {
        int x = 1,y = m;
        while (x <= n && y >= 1) {
            if (matrix[x][y] == c) return make_pair(x,y);
            if (matrix[x][y] < c) x++;
            if (matrix[x][y] > c) y--;
        }
        return make_pair(0,0);
    }
    void showMatrix() {
        for (int i=1;i<=n;i++) {
            for (int j=1;j<=m;j++) {
                cout<<matrix[i][j]<<" ";
            }
            cout<<endl;
        }
    }
};