洛谷模拟NOIP考试反思

最新推荐文章于 2019-08-12 21:48:00 发布
最新推荐文章于 2019-08-12 21:48:00 发布
阅读量107 收藏
点赞数
原文链接：http://www.cnblogs.com/irischen/p/PJ2018-try-test1.html
版权

洛谷模拟NOIP考试反思

想法

考了这么简单的试qwq然而依然emmmmmm成绩不好
虽然本次难度应该是大于正常PJ难度的但还是很不理想，离预估分数差很多qwq
于是就有了本反思嘤嘤嘤

比赛链接

原比赛链接（已结束但仍然可提交）

题目解析反思

第一题

超简单（虽然仍然没做对）
1502642-20181004190315541-914472881.png

第二题

1502642-20181004190350961-638019555.png
1502642-20181004190424096-1451571778.png
代码扔上来qwq（虽然还是不会）

1502642-20181004190940113-1745090425.png

第三题

1502642-20181004191421781-1492359823.png
1502642-20181004191708163-2018879501.png
代码
1502642-20181004191819443-669533624.png

第四题

1502642-20181004193236190-141528495.png
毒瘤极了wodema
据说原来数据是50%那里的，但是出题人z某灵机一动加到了1000orz
于是很多人自然而然地想到了状压DP
普及组是到不了这个难度的，主要是z某他太坏了
50分做法（状压）
1502642-20181004193254271-1647164761.png

正解的100分正法并非毒瘤状压qwq
1502642-20181004194131805-1711397780.png
1502642-20181004200002566-1292786661.png

（有人说爆搜能骗40分？！）

讲评者
1502642-20181004200104380-2118182796.png
XD
---

TG

还是放一道TG第三题压压惊好了

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
typedef long long int LL;
const int Max_N(100050);
const int Max_M(100050);
const int Max_Q(100050);

template<typename Type>
void gi(Type &Ret)
{
    Ret = 0;
    char ch;
    while (ch = getchar(), ch > '9' || ch < '0')
        ;
    do
    {
        (Ret *= 10) += ch - '0';
    }
    while (ch = getchar(), ch >= '0' && ch <= '9');
}

inline int Abs(const int &x)
{
    return x >= 0 ? x : -x;
}

int N, M, Q, X1[Max_N + Max_Q], Y1[Max_N + Max_Q], X2[Max_N + Max_Q], Y2[Max_N + Max_Q];
int L[Max_N + Max_Q], R[Max_N + Max_Q], D[Max_N + Max_Q], U[Max_N + Max_Q], Anc[60][Max_N];
LL T[Max_N + Max_Q], Sum[60][Max_N];

#define LEFT  (segt[cur].l)
#define RIGHT (segt[cur].r)
#define MID   (segt[cur].mid)
#define COV   (segt[cur].Cov)
#define TAG   (segt[cur].Tag)
#define LCH   (cur << 1)
#define RCH   ((cur << 1) | 1)

struct node
{
    int l, r, mid, Cov, Tag;
};
node segt[Max_M << 2];
int C[Max_M];

void build_tree(const int &cur, const int &l, const int &r)
{
    LEFT = l, RIGHT = r, MID = l + ((r - l) >> 1), COV = TAG = 0;
    if (l == r)
        return;
    build_tree(LCH, l, MID), build_tree(RCH, MID + 1, r);
}

inline void cover(const int &cur, const int &v)
{
    COV = TAG = v;
}

inline void pushdown(const int &cur)
{
    if (TAG)
        cover(LCH, TAG), cover(RCH, TAG), TAG = 0;
}

void cover(const int &cur, const int &l, const int &r, const int &v)
{
    if (LEFT == l && RIGHT == r)
    {
        cover(cur, v);
        return;
    }
    pushdown(cur);
    if (r <= MID)
        cover(LCH, l, r, v);
    else
        if (l > MID)
            cover(RCH, l, r, v);
        else
            cover(LCH, l, MID, v), cover(RCH, MID + 1, r, v);
}

int query(const int &cur, const int &pos)
{
    if (LEFT == RIGHT)
        return COV;
    pushdown(cur);
    if (pos <= MID)
        return query(LCH, pos);
    else
        return query(RCH, pos);
}

inline bool compL(const int &a, const int &b)
{
    return min(X1[a], X2[a]) < min(X1[b], X2[b]);
}

void goL()
{
    build_tree(1, 0, M), memset(C, 0, sizeof(C));
    sort(L + 1, L + 1 + L[0], compL);
    sort(R + 1, R + 1 + R[0], compL);
    sort(D + 1, D + 1 + D[0], compL);
    sort(U + 1, U + 1 + U[0], compL);
    for (int l = 1, r = 1, d = 1, u = 1, a, b, p;l <= L[0];++l)
    {
        p = L[l];
        while (r <= R[0] && X1[R[r]] <= X2[p])
        {
            if (R[r] <= N)
                C[Y2[R[r]]] = R[r];
            ++r;
        }
        while ((d <= D[0] && X2[D[d]] <= X2[p]) || (u <= U[0] && X2[U[u]] <= X2[p]))
            if ((d <= D[0]) && (u > U[0] || X2[D[d]] <= X2[U[u]]))
            {
                if (D[d] <= N)
                    cover(1, Y2[D[d]], Y1[D[d]], D[d]);
                ++d;
            }
            else
            {
                if (U[u] <= N)
                    cover(1, Y1[U[u]], Y2[U[u]], U[u]);
                ++u;
            }
        a = query(1, Y2[p]), b = C[Y2[p]];
        if (p <= N)
        {
            if (a == 0 && b == 0)
                Anc[0][p] = -1;
            else
                if (a && (b == 0 || X2[p] - X2[a] < X2[p] - X2[b]))
                    Anc[0][p] = a, Sum[0][p] = (X2[p] - X2[a]) + Abs(Y2[p] - Y2[a]);
                else
                    Anc[0][p] = b, Sum[0][p] = X2[p] - X2[b];
        }
        else
        {
            if (a == 0 && b == 0)
                X2[p] = max(0LL, X2[p] - T[p]), T[p] = 0LL;
            else
                if (a && (b == 0 || X2[p] - X2[a] < X2[p] - X2[b]))
                    if (T[p] <= X2[p] - X2[a])
                        X2[p] -= T[p], T[p] = 0LL;
                    else
                    {
                        T[p] -= X2[p] - X2[a], X2[p] = X2[a];
                        if (T[p] <= Abs(Y2[p] - Y2[a]))
                        {
                            if (Y2[a] <= Y2[p])
                                Y2[p] -= T[p];
                            else
                                Y2[p] += T[p];
                            T[p] = 0LL;
                        }
                        else
                            T[p] -= Abs(Y2[p] - Y2[a]), X2[p] = a;
                    }
                else
                    if (T[p] <= Abs(X2[p] - X2[b]))
                    {
                        if (X2[b] <= X2[p])
                            X2[p] -= T[p];
                        else
                            X2[p] += T[p];
                        T[p] = 0LL;
                    }
                    else
                        T[p] -= Abs(X2[p] - X2[b]), X2[p] = b;
        }
    }
}

inline int getR(const int &x)
{
    return max(X1[x], X2[x]);
}

inline bool compR(const int &a, const int &b)
{
    return getR(a) > getR(b);
}

void goR()
{
    build_tree(1, 0, M), memset(C, 0, sizeof(C));
    sort(L + 1, L + 1 + L[0], compR);
    sort(R + 1, R + 1 + R[0], compR);
    sort(D + 1, D + 1 + D[0], compR);
    sort(U + 1, U + 1 + U[0], compR);
    for (int l = 1, r = 1, d = 1, u = 1, a, b, p;r <= R[0];++r)
    {
        p = R[r];
        while (l <= L[0] && getR(L[l]) >= getR(p))
        {
            if (L[l] <= N)
                C[Y2[L[l]]] = L[l];
            ++l;
        }
        while ((d <= D[0] && getR(D[d]) >= getR(p)) || (u <= U[0] && getR(U[u]) >= getR(p)))
            if ((d <= D[0]) && (u > U[0] || getR(D[d]) >= getR(U[u])))
            {
                if (D[d] <= N)
                    cover(1, Y2[D[d]], Y1[D[d]], D[d]);
                ++d;
            }
            else
            {
                if (U[u] <= N)
                    cover(1, Y1[U[u]], Y2[U[u]], U[u]);
                ++u;
            }
        a = query(1, Y2[p]), b = C[Y2[p]];
        if (p <= N)
        {
            if (a == 0 && b == 0)
                Anc[0][p] = -1;
            else
                if (a && (b == 0 || X2[a] - X2[p] < X2[b] - X2[p]))
                    Anc[0][p] = a, Sum[0][p] = (X2[a] - X2[p]) + Abs(Y2[p] - Y2[a]);
                else
                    Anc[0][p] = b, Sum[0][p] = X2[b] - X2[p];
        }
        else
        {
            if (a == 0 && b == 0)
                X2[p] = min(M * 1LL, X2[p] + T[p]), T[p] = 0LL;
            else
                if (a && (b == 0 || X2[a] - X2[p] < X2[b] - X2[p]))
                    if (T[p] <= X2[a] - X2[p])
                        X2[p] += T[p], T[p] = 0LL;
                    else
                    {
                        T[p] -= X2[a] - X2[p], X2[p] = X2[a];
                        if (T[p] <= Abs(Y2[p] - Y2[a]))
                        {
                            if (Y2[a] <= Y2[p])
                                Y2[p] -= T[p];
                            else
                                Y2[p] += T[p];
                            T[p] = 0LL;
                        }
                        else
                            T[p] -= Abs(Y2[p] - Y2[a]), X2[p] = a;
                    }
                else
                    if (T[p] <= Abs(X2[b] - X2[p]))
                    {
                        if (X2[b] <= X2[p])
                            X2[p] -= T[p];
                        else
                            X2[p] += T[p];
                        T[p] = 0LL;
                    }
                    else
                        T[p] -= Abs(X2[b] - X2[p]), X2[p] = b;
        }
    }
}

inline int getD(const int &x)
{
    return min(Y1[x], Y2[x]);
}

inline bool compD(const int &a, const int &b)
{
    return getD(a) < getD(b);
}

void goD()
{
    build_tree(1, 0, M), memset(C, 0, sizeof(C));
    sort(L + 1, L + 1 + L[0], compD);
    sort(R + 1, R + 1 + R[0], compD);
    sort(D + 1, D + 1 + D[0], compD);
    sort(U + 1, U + 1 + U[0], compD);
    for (int l = 1, r = 1, d = 1, u = 1, a, b, p;d <= D[0];++d)
    {
        p = D[d];
        while (u <= U[0] && getD(U[u]) <= getD(p))
        {
            if (U[u] <= N)
                C[X2[U[u]]] = U[u];
            ++u;
        }
        while ((l <= L[0] && getD(L[l]) <= getD(p)) || (r <= R[0] && getD(R[r]) <= getD(p)))
            if ((l <= L[0]) && (r > R[0] || getD(L[l]) <= getD(R[r])))
            {
                if (L[l] <= N)
                    cover(1, X2[L[l]], X1[L[l]], L[l]);
                ++l;
            }
            else
            {
                if (R[r] <= N)
                    cover(1, X1[R[r]], X2[R[r]], R[r]);
                ++r;
            }
        a = query(1, X2[p]), b = C[X2[p]];
        if (p <= N)
        {
            if (a == 0 && b == 0)
                Anc[0][p] = -1;
            else
                if (a && (b == 0 || Y2[p] - Y2[a] < Y2[p] - Y2[b]))
                    Anc[0][p] = a, Sum[0][p] = (Y2[p] - Y2[a]) + Abs(X2[p] - X2[a]);
                else
                    Anc[0][p] = b, Sum[0][p] = Y2[p] - Y2[b];
        }
        else
        {
            if (a == 0 && b == 0)
                Y2[p] = max(0LL, Y2[p] - T[p]), T[p] = 0LL;
            else
                if (a && (b == 0 || Y2[p] - Y2[a] < Y2[p] - Y2[b]))
                    if (T[p] <= Y2[p] - Y2[a])
                        Y2[p] -= T[p], T[p] = 0LL;
                    else
                    {
                        T[p] -= Y2[p] - Y2[a], Y2[p] = Y2[a];
                        if (T[p] <= Abs(X2[p] - X2[a]))
                        {
                            if (X2[a] <= X2[p])
                                X2[p] -= T[p];
                            else
                                X2[p] += T[p];
                            T[p] = 0LL;
                        }
                        else
                            T[p] -= Abs(X2[p] - X2[a]), X2[p] = a;
                    }
                else
                    if (T[p] <= Abs(Y2[p] - Y2[b]))
                    {
                        if (Y2[b] <= Y2[p])
                            Y2[p] -= T[p];
                        else
                            Y2[p] += T[p];
                        T[p] = 0LL;
                    }
                    else
                        T[p] -= Abs(Y2[p] - Y2[b]), X2[p] = b;
        }
    }
}

inline int getU(const int &x)
{
    return max(Y1[x], Y2[x]);
}

inline bool compU(const int &a, const int &b)
{
    return getU(a) > getU(b);
}

void goU()
{
    build_tree(1, 0, M), memset(C, 0, sizeof(C));
    sort(L + 1, L + 1 + L[0], compU);
    sort(R + 1, R + 1 + R[0], compU);
    sort(D + 1, D + 1 + D[0], compU);
    sort(U + 1, U + 1 + U[0], compU);
    for (int l = 1, r = 1, d = 1, u = 1, a, b, p;u <= U[0];++u)
    {
        p = U[u];
        while (d <= D[0] && getU(D[d]) >= getU(p))
        {
            if (D[d] <= N)
                C[X2[D[d]]] = D[d];
            ++d;
        }
        while ((l <= L[0] && getU(L[l]) >= getU(p)) || (r <= R[0] && getU(R[r]) >= getU(p)))
            if ((l <= L[0]) && (r > R[0] || getU(L[l]) >= getU(R[r])))
            {
                if (L[l] <= N)
                    cover(1, X2[L[l]], X1[L[l]], L[l]);
                ++l;
            }
            else
            {
                if (R[r] <= N)
                    cover(1, X1[R[r]], X2[R[r]], R[r]);
                ++r;
            }
        a = query(1, X2[p]), b = C[X2[p]];
        if (p <= N)
        {
            if (a == 0 && b == 0)
                Anc[0][p] = -1;
            else
                if (a && (b == 0 || Y2[a] - Y2[p] < Y2[b] - Y2[p]))
                    Anc[0][p] = a, Sum[0][p] = (Y2[a] - Y2[p]) + Abs(X2[p] - X2[a]);
                else
                    Anc[0][p] = b, Sum[0][p] = Y2[b] - Y2[p];
        }
        else
        {
            if (a == 0 && b == 0)
                Y2[p] = min(M * 1LL, Y2[p] + T[p]), T[p] = 0LL;
            else
                if (a && (b == 0 || Y2[a] - Y2[p] < Y2[b] - Y2[p]))
                    if (T[p] <= Y2[a] - Y2[p])
                        Y2[p] += T[p], T[p] = 0LL;
                    else
                    {
                        T[p] -= Y2[a] - Y2[p], Y2[p] = Y2[a];
                        if (T[p] <= Abs(X2[p] - X2[a]))
                        {
                            if (X2[a] <= X2[p])
                                X2[p] -= T[p];
                            else
                                X2[p] += T[p];
                            T[p] = 0LL;
                        }
                        else
                            T[p] -= Abs(X2[p] - X2[a]), X2[p] = a;
                    }
                else
                    if (T[p] <= Abs(Y2[b] - Y2[p]))
                    {
                        if (Y2[b] <= Y2[p])
                            Y2[p] -= T[p];
                        else
                            Y2[p] += T[p];
                        T[p] = 0LL;
                    }
                    else
                        T[p] -= Abs(Y2[b] - Y2[p]), X2[p] = b;
        }
    }
}

void get(const int &i, const int &u)
{
    if (X2[u] < X1[u])
        X2[i] = max(0LL, X2[i] - T[i]);
    if (X2[u] > X1[u])
        X2[i] = min(M * 1LL, X2[i] + T[i]);
    if (Y2[u] < Y1[u])
        Y2[i] = max(0LL, Y2[i] - T[i]);
    if (Y2[u] > Y1[u])
        Y2[i] = min(M * 1LL, Y2[i] + T[i]);
}

int main()
{

    gi(N), gi(M);
    for (int i = 1;i <= N;++i)
    {
        gi(X1[i]), gi(Y1[i]), gi(X2[i]), gi(Y2[i]);
        if (X2[i] < X1[i])
            L[++L[0]] = i;
        if (X2[i] > X1[i])
            R[++R[0]] = i;
        if (Y2[i] < Y1[i])
            D[++D[0]] = i;
        if (Y2[i] > Y1[i])
            U[++U[0]] = i;
    }
    gi(Q);
    for (int i = 1;i <= Q;++i)
    {
        gi(X2[N + i]), gi(Y2[N + i]), X1[N + i] = X2[N + i], Y1[N + i] = Y2[N + i];
        char op[5];
        scanf("%s", op);
        if (*op == 'L')
            L[++L[0]] = N + i;
        if (*op == 'R')
            R[++R[0]] = N + i;
        if (*op == 'D')
            D[++D[0]] = N + i;
        if (*op == 'U')
            U[++U[0]] = N + i;
        gi(T[N + i]);
    }
    goL(), goR(), goD(), goU();
    for (int j = 1;j <= 59;++j)
        for (int i = 1;i <= N;++i)
            if (Anc[j - 1][i] == -1)
                Anc[j][i] = -1;
            else
            {
                Anc[j][i] = Anc[j - 1][Anc[j - 1][i]];
                Sum[j][i] = Sum[j - 1][i] + Sum[j - 1][Anc[j - 1][i]];
                Sum[j][i] = min(Sum[j][i], 1000000000000000LL + 1LL);
            }
    for (int i = N + 1, u;i <= N + Q;++i)
    {
        if (T[i])
        {
            u = X2[i];
            for (int j = 59;j >= 0;--j)
                if (Anc[j][u] != -1 && Sum[j][u] <= T[i])
                    T[i] -= Sum[j][u], u = Anc[j][u];
            X2[i] = X2[u], Y2[i] = Y2[u];
            if (Anc[0][u] == -1)
                get(i, u);
            else
            {
                if (X2[u] < X1[u])
                    if (T[i] <= X2[i] - X2[Anc[0][u]])
                        get(i, u);
                    else
                        T[i] -= X2[i] - X2[Anc[0][u]], X2[i] = X2[Anc[0][u]], get(i, Anc[0][u]);
                if (X2[u] > X1[u])
                    if (T[i] <= X2[Anc[0][u]] - X2[i])
                        get(i, u);
                    else
                        T[i] -= X2[Anc[0][u]] - X2[i], X2[i] = X2[Anc[0][u]], get(i, Anc[0][u]);
                if (Y2[u] < Y1[u])
                    if (T[i] <= Y2[i] - Y2[Anc[0][u]])
                        get(i, u);
                    else
                        T[i] -= Y2[i] - Y2[Anc[0][u]], Y2[i] = Y2[Anc[0][u]], get(i, Anc[0][u]);
                if (Y2[u] > Y1[u])
                    if (T[i] <= Y2[Anc[0][u]] - Y2[i])
                        get(i, u);
                    else
                        T[i] -= Y2[Anc[0][u]] - Y2[i], Y2[i] = Y2[Anc[0][u]], get(i, Anc[0][u]);
            }
        }
        printf("%d %d\n", X2[i], Y2[i]);
    }
    return 0;

1502642-20181004195538425-1466462526.png

转载于:https://www.cnblogs.com/irischen/p/PJ2018-try-test1.html

weixin_30908649
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2020洛谷初赛模拟.pdf
10-10
2020洛谷初赛模拟, 简介 针对 2019 年 CSP 非专业组第一轮（相当于原 NOIP 初赛）的题目改革，我们命制了一套第一轮的模拟试卷。 本次模拟测试形式和 CSP 第一轮 完 全 一 致，难度介于 J 组（基础组）和 S 组...
Noip2018赛后反思
A.pro的博客
11-14 401
11月…… OIer们的新年，是逐梦多年的选手们封神还是退役成败在此一举的时刻。        又是一场Noip，又是一次轮回。一封耕耘一分收获，汗水不会欺骗自己。但是我心里仍有一丝不甘，它好像在埋怨，在心中咆哮。        这是我第二次参加Noip。我并没有考好。也许我普及组能拿到1=，也许拿不到。可能在我心中没有遗憾，因为我付出了。可能在我心中有点遗憾，因为我的提高组是彻底凉凉。不管怎...
NOIP2005提高组题解
Hi_KER的博客
08-10 867
T1:谁拿了最多奖学金 考察知识：模拟，条件语句 算法难度：X 实现难度：X+ 分析：初学者都能做，只要细心把所有条件都考虑完就可以了。 算法流程： 1.读入n 2.循环n次，一边读入数据一边判断可以得那些奖学金，并按题目要求处理 代码： #include&lt;cstdio&gt; #include&lt;cstring&gt; char top_stu[25],name[25...
2019.8.7 NOIP模拟测试14 反思总结
weixin_30905133的博客
08-08 137
先扔代码 调完自闭网络流了，新一轮考试前看看能不能赶完…… 考得极其爆炸，心态也极其爆炸，真的是认识到自己能力上的不足 思维跑偏，代码能力差 就这样吧，再努力努力，不行就AFO T1旋转子段： 因为我和正解的绝缘性，我上来先选择想暴力，搞了搞把暴力优化到n2，行了，就交了 大约是想正解的时候被奇怪的问题hack掉没有解决，于是被踢出了正解门外 这边正...
2019.8.12 NOIP模拟测试18 反思总结
weixin_30905133的博客
08-12 150
写个博客总是符合要求的对吧 回来以后第一次悄悄参加考试，昨天全程围观… 然后喜提爆炸120分wwwwwwwww T1用了全机房最慢的写法，导致改掉死循环T掉的一个点以后还是死活过不了最后一个点。T2全世界都会DP只有我没做过关路灯也现场推不出来我不如原地爆炸死得干脆一点还非要DFs骗个40分。T3浪费两个小时，考后不甘心地尝试理解题解和std然后死得如烟花一般惨淡。 哇，墨...
noip考试策略和技巧
11-17
noip考试策略和技巧
NOIP初赛模拟题.pdf
08-07
NOIP初赛模拟题.pdf
NOIP考试注意事项.txt
11-23
noip考试需要注意的事项，例如：可以估计复杂度，比如10^9可能需要根号或log级别的，如果10^18，那么log才行，如果就300或100，可以O(n^3)，如果数很小，可以用阶乘或幂次的了
NOIP模拟题一套
05-16
NOIP2017模拟题，带题面，数据，标程，题解。 难度与联赛相近，考点均在联赛范围内 NOIP2017模拟题，带题面，数据，标程，题解。 难度与联赛相近，考点均在联赛范围内
python学习导航.txt
05-06
python
node-v8.3.0-linux-s390x.tar.xz
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
嵌入式微处理器设计及应用
05-06
摘要：为满足智能家居座椅的交互式运动控制需求，基于AT89S52设计了嵌入式座椅运动控制系统。使用VB.net设计了游戏手柄按键读取软件，并在此基础上设计了座椅运动控制软件，软件可分别在“手柄模式”和“鼠标模式”下与嵌入式座椅运动控制器通信，进而控制座椅进行加速、减速、正转和反转等运动；构建了控制系统实验装置，实验结果表明，“鼠标模式”下，通过鼠标点击控制软件上功能按钮可实现对座椅的准确运动控制；“手柄模式”下，游戏手柄不仅可控制座椅运动，还可同步控制电脑上运行的游戏或远程遥控车，实现浸入感较强的座椅运动娱乐应用。
2024年中国NFC RFID阅读器行业研究报告.docx
05-06
2024年中国NFC RFID阅读器行业研究报告
node-v9.9.0-linux-ppc64le.tar.xz
最新发布
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
04-18 周四 为LLM-inference项目配置GitHub CI过程记录
05-06
04-18 周四 为LLM-inference项目配置GitHub CI过程记录
2024年中国AI和机器视觉行业研究报告.docx
05-06
2024年中国AI和机器视觉行业研究报告
计算机二级【公共基础知识速学教程】.pdf
05-06
内容概要：这份资料包含了计算机二级公共基础知识速学教程的内容大纲，涵盖了数据结构与算法、程序设计基础、软件工程基础、数据库设计基础等多个章节。其中包括了算法复杂度、数据结构、栈、队列、链表、二叉树、查找、排序等内容，以及程序设计方法、软件工程概念、数据库设计原理等知识点。 适用人群：适合希望系统学习计算机二级公共基础知识的学生、计算机专业学习者、程序员、软件工程师以及对数据结构、算法和数据库设计感兴趣的人群，希望通过系统学习提升自己的计算机基础知识和技能。 使用场景及目标：该教程可用于计算机相关专业的课程学习、自学提升或备考计算机二级公共基础考试。学习者可以通过逐章学习和实践，掌握数据结构与算法、程序设计基础、软件工程基础和数据库设计基础等知识，提高自己在计算机领域的理论基础和实践能力。 其他说明：学习者在使用这份教程时，可以结合实际案例和练习题进行深入学习和巩固。建议按照章节顺序系统学习，理解各个知识点的概念和应用，并通过实践项目或练习加深对计算机基础知识的理解和掌握。通过系统学习，可以提升自己在计算机领域的专业水平和能力。
减肥管理，全球前10强生产商排名及市场份额.docx
05-06
减肥管理，全球前10强生产商排名及市场份额
洛谷的[NOIP1999 普及组] 导弹拦截
02-06
洛谷的[NOIP1999 普及组] 导弹拦截 是一道程序设计题。 题目大意是这样的：有一个国家发射了若干枚导弹，它们从不同的高度飞行，你有若干个导弹拦截器可以用来摧毁导弹。每个导弹拦截器的射程是固定的，并且它可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值