雅礼学习10.6

雅礼学习10.6

上午考试

各题状况

T1

二分答案

应该有反例,就是说,答案应该不是单调的

但是不会写其他的算法了啊。。。

T2

我TM。。。

第二个红框圈出来的部分应该是

if(x1+x1!=s)

写错了,就没了\(18\)分。。

T3

写了个\(n^4\)的暴力

最后发现题目中的矩形的四个顶点不一定是给定的顶点。。

那就GG了

各题题目及考场代码

T1

/*
 * 二分答案。。
 * 复杂度O(20(N+NlogN+M))的,感觉很悬
 * 排序应该可以优化掉,但是不太会哎。
 */
#include <cstdio>
#include <algorithm>

inline int read()
{
    int n=0,w=1;register char c=getchar();
    while(c<'0' || c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c>='0' && c<='9')n=n*10+c-'0',c=getchar();
    return n*w;
}

const int N=1e6+1;
int n,m;
struct Seg{
    int b,k;
}seg[N];
long long S,emp[N];

inline bool judge(long long x)
{
    for(int i=1;i<=n;++i)
        emp[i]=seg[i].k*x+seg[i].b;
    std::sort(emp+1,emp+1+n);
/*
    for(int i=1;i<=n;++i)
        printf("%lld ",emp[i]);
    puts("");
*/
    long long res=0;
    for(int i=0;i<m;++i)
    {
        if(emp[n-i]<0)break;
        res+=emp[n-i];
    }
//  printf("%lld\n",res);
    return res>=S;
}

int main()
{
    freopen("merchant.in","r",stdin);
    freopen("merchant.out","w",stdout);

    n=read(),m=read();
    scanf("%lld",&S);
//  printf("%d %d %lld\n",n,m,S);
    for(int i=1;i<=n;++i)
    {
        seg[i].k=read(),seg[i].b=read();
//      printf("%d %d\n",seg[i].k,seg[i].b);
    }
    int l=0,r=1e9,mid;
    while(l<=r)
    {
        mid=l+r>>1;
        if(judge(mid))
            r=mid-1;
        else    l=mid+1;
    }
    printf("%d",l);

    fclose(stdin),fclose(stdout);
    return 0;
}

T2


/*
 * 题目描述什么鬼啊。。。完全看不懂
 *
 * emmmm
 * 高斯消元么。。。
 */
#include <cstdio>
#include <algorithm>
inline int read()
{
    int n=0,w=1;register char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c>='0'&&c<='9')n=n*10+c-'0',c=getchar();
    return n*w;
}
const int N=1e6+1;
int n,q,fa[N],w[N];
/*
const double eps=1e-8;
double a[N][N];

int sign(double x)
{//判断一个数是正数、负数还是0
    if(fabs(x)<=eps)return 0;//fabs是对浮点数取绝对值
    if(x>0)return 1;
    return -1;
}

inline void GG(int x)
{
    if(a[x][n+1])
        puts("none");
    else    puts("inf");
}

inline void solve()
{
    for(int i=1;i<=n;++i)
        a[i][n+1]=b[i];//得到扩展矩阵

    for(int i=1;i<=n;++i)
    {
        int p=i;
        for(int j=i+1;j<=n;++j)
            if(fabs(a[j][i]>fabs(a[p][i])))
                p=j;
        for(int j=1;j<=n+1;++j)
            swap(a[p][j],a[i][j]);
        if(sign(a[i][i])==0)
            GG(i);
        for(int j=i+1;j<=n;++j)
        {
            double ratio=a[j][i]/a[i][i];//计算是多少倍
            for(int k=1;k<=n+1;++k)
                a[j][k]=a[j][k]-ratio*a[i][k];
        }
        for(int i=n;i>0;--i)
        {
            for(int j=i+1;j<=n;++j)
                a[i][n+1]=a[i][n+1]-x[j]*a[i][j];
            x[i]=a[i][n+1]/a[i][i];
        }
}

int main()
{
    freopen("equation.in","r",stdin);
    freopen("equation.out","w",stdout);
    n=read(),q=read();
    for(int i=2;i<=n;++i)
        fa[i]=read(),w[i]=read();
    int type,u,v,s;
    while(q--)
    {
        type=read(),u=read(),v=read();
        if(type==1)
        {
            s=read();
            solve();
        }
        else
        {
            w[u]=v;
            a[u][fa[u]]=v;
        }
    }
    fclose(stdin);fclose(stdout);
    return 0;
}
日。。
写挂了
*/
int main()
{
    freopen("equation.in","r",stdin);
    freopen("equation.out","w",stdout);
    n=read(),q=read();
    for(int i=2;i<=n;++i)
        fa[i]=read(),w[i]=read();
    int type,u,v,s;
    int x2,x1;
    if(n==2)
    {
        while(q--)
        {
            type=read(),u=read(),v=read();
            if(type==1)
            {
                s=read();
                if(u==v && v==2)
                {
                    x2=s/2;
                    if(x2+x2!=s)
                        puts("none");
                    else    printf("%d\n",w[2]-x2);
                }
                else
                    if(u==v && v==1)
                    {
                        x1=s/2;
                        if(x2+x2!=s)
                            puts("none");
                        else    printf("%d\n",x1);
                    }
                    else
                    {
                        if(s==w[2])
                            puts("inf");
                        else    puts("none");
                    }
            }
            else    w[u]=v;
        }
    }
    else
    {
        while(q--)
        {
            srand(19260817);
            while(q--)
            {
                int x=rand();
                if(x%3==1)
                    puts("none");
                else
                    if(x%3==2)
                        puts("inf");
                    else    printf("%d\n",x);
            }
        }
    }
    fclose(stdin);fclose(stdout);
    return 0;
}

T3


#include <cstdio>
#include <map>

const int N=2501,mod=1e9+7;
std::map<int,bool> mp1,mp2;
int n,t1,t2,lx,ly,rx,ry;
int ans,x[N],y[N];

inline int read()
{
    int n=0,w=1;register char c=getchar();
    while(c<'0' || c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c>='0' && c<='9')n=n*10+c-'0',c=getchar();
    return n*w;
}

inline int min(int x,int y)
{return x<y?x:y;}
inline int max(int x,int y)
{return x>y?x:y;}

int main()
{
    freopen("rectangle.in","r",stdin);
    freopen("rectangle.out","w",stdout);
    n=read();
    for(int i=1;i<=n;++i)
        x[i]=read(),y[i]=read();
    for(int i=1;i<=n;++i)
        for(int j=1;j<=n;++j)
            for(int q=1;q<=n;++q)
                for(int p=1;p<=n;++p)
                {
                    if(i==j&&j==q&&q==p)continue;
                    lx=min(min(x[i],x[j]),min(x[q],x[p]));
                    ly=min(min(y[i],y[j]),min(y[q],y[p]));
                    rx=max(max(x[i],x[j]),max(x[q],x[p]));
                    ry=max(max(y[i],y[j]),max(y[q],y[p]));
                    t1=(lx*ry+ly*rx);
                    t2=(lx*rx+ly*ry);
                    if(mp1[t1]==0&&mp2[t2]==0)
                    {
                        ans=(ans+(rx-lx)*(ry-ly))%mod;
                        mp1[t1]=mp2[t2]=1;
                    }
                }
    printf("%d",ans);
    fclose(stdin);fclose(stdout);
    return 0;
}

正解及代码

T1

选择任意一个集合,得到的收益和都可以表示为一个一次函数的形式。

我们只关心这些一次函数的最大值,可以发现这个最大值一定是先降后增、单调递增或者单调递减。

因此我们只需要\(check\)一下\(0\)时刻是否符合条件,如果不符合则进行二分。 注意\(check\)的时候我们只需要找出最大的\(m\)个即可,因此可以\(O(n)\)地做,具体做法是快排的过程中只递归一边,或者直接用\(STL\)的\(nth_element()\)即可

#include <bits/stdc++.h>

#define For(i, j, k) for (int i = j; i <= k; i++)

using namespace std;

const int N = 1e6 + 10;

typedef long long LL;

int n, m;
LL S;

int k[N], b[N];
LL val[N];

bool check(int x) {
    For(i, 1, n) val[i] = 1ll * k[i] * x + b[i];
    nth_element(val + 1, val + m, val + n + 1, greater<LL>());
    LL sum = 0;
    For(i, 1, m) if (val[i] > 0 && (sum += val[i]) >= S) return true;
    return sum >= S;
}

int main() {

    scanf("%d%d%lld", &n, &m, &S);
    For(i, 1, n) scanf("%d%d", &k[i], &b[i]);

    if (check(0)) { puts("0"); return 0; }

    int L = 1, R = 1e9;
    while (L < R) {
        int mid = (L + R) / 2;
        if (check(mid)) R = mid;
        else L = mid + 1;
    }
    printf("%d\n", L);

    return 0;
}

T2

每个变量都可以表示成\(x_i=k+x_1\)或者\(x_i=k?x_1\)的形式,表示为这个形式之后就可以方便地回答询问了。

对于询问\(1\),只需要将表示\(u\)和\(v\)的式子加起来,这时会出现两种情况:要么会得到\(x_u+x_v=t\)的形式,此时只需要判断是否有\(s=t\);要么会得到\(x_u+x_v=t+2x_1\)或\(x_u+x_v=t?2x_1\),此时可以解出\(x_1\),注意判断解是否是整数即可。

对于修改操作,实际上是修改一个子树内的变量的\(k\),这里可以将深度为奇数和偶数的点分开考虑,不难发现就是区间加减。由于只需要单点询问,用一个树状数组维护即可

\(O((n+q)\log n)?\)

#include <bits/stdc++.h>

#define getchar getchar_unlocked
#define For(i, j, k) for (int i = j; i <= k; i++)

using namespace std;

int Read() {
    char c = getchar(); int x = 0;
    int sig = 1;
    while (c < '0' || c > '9') { if (c == '-') sig = -1; c = getchar(); }
    while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * sig;
}

const int N = 1e6 + 10;

int n, q;

struct Binary_Indexed_Tree {

    int c[N];

    inline int lowbit(int x) {
        return x & (-x);
    }

    void add(int x, int w) {
        while (x <= n) {
            c[x] += w;
            x += lowbit(x);
        }
    }

    int sum(int x) {
        int ret = 0;
        while (x) {
            ret += c[x];
            x -= lowbit(x);
        }
        return ret;
    }

}T;

int dfn[N], rdfn[N], dep[N];
int fa[N], w[N];
vector<int> G[N];

void DFS_init(int o) {
    static int clk = 0;
    dfn[o] = ++clk;
    for (int v : G[o]) dep[v] = dep[o] ^ 1, DFS_init(v);
    rdfn[o] = clk;
}

int main() {

    n = Read(), q = Read();
    For(i, 2, n) fa[i] = Read(), w[i] = Read(), G[fa[i]].push_back(i);
    DFS_init(1);
    For(i, 2, n) if (!dep[i]) w[i] = -w[i];
    For(i, 2, n) T.add(dfn[i], w[i]), T.add(rdfn[i] + 1, -w[i]);

    while (q--) {
        int op = Read();
        if (op == 1) {
            int u = Read(), v = Read(), s = Read();
            int x = T.sum(dfn[u]), y = T.sum(dfn[v]);

            if (dep[u] && dep[v]) {
                long long rt = 1ll * x + y - s;
                if (rt % 2) puts("none");
                else printf("%lld\n", rt / 2);
            } else if (!dep[u] && !dep[v]) {
                long long rt = 1ll * x + y + s;
                if (rt % 2) puts("none");
                else printf("%lld\n", rt / 2);
            } else {
                if (dep[v]) swap(u, v), swap(x, y);
                if (x - y == s) puts("inf");
                else puts("none");
            }

        } else {
            int u = Read(), nw = Read();
            if (!dep[u]) nw = -nw;
            T.add(dfn[u], nw - w[u]), T.add(rdfn[u] + 1, w[u] - nw);
            w[u] = nw;
        }
    }

    return 0;
}

T3

#include <bits/stdc++.h>

#define For(i, j, k) for (int i = j; i <= k; i++)
#define Forr(i, j, k) for (int i = j; i >= k; i--)

using namespace std;

const int N = 2510;
const int Mod = 1e9 + 7;

int n, m = 2500;

struct Binary_Indexed_Tree {

    int c[N];

    void init() {
        For(i, 1, m) c[i] = 0;
    }

    int lowbit(int x) { return x & (-x); }

    void add(int x, int w) {
        for (; x <= m; x += lowbit(x)) c[x] += w;
    }

    int sum(int x) {
        int ret = 0;
        for (; x; x -= lowbit(x)) ret += c[x];
        return ret;
    }

}T, S;

int pos[N][N];
int c[N];
bool vis[N];

void upd(int x) {
    if (vis[x]) return;
    vis[x] = true;
    T.add(x, 1), S.add(x, x);
}

int main() {

    scanf("%d", &n);
    For(i, 1, n) {
        int x, y;
        scanf("%d%d", &x, &y);
        pos[x][++c[x]] = y;
    }

    For(i, 1, m) sort(pos[i] + 1, pos[i] + c[i] + 1), pos[i][c[i] + 1] = m + 1;

    int ans = 0;
    For(i, 1, m) if (c[i]) {
        T.init(), S.init();
        For(j, 1, m) vis[j] = false;
        For(j, 1, c[i]) upd(pos[i][j]);
        Forr(j, i - 1, 1) if (c[j]) {
            int pa = 1, pb = 1, cur = max(pos[i][1], pos[j][1]);
            For(k, 1, c[j]) upd(pos[j][k]);
            while (pos[i][pa + 1] <= cur) ++pa;
            while (pos[j][pb + 1] <= cur) ++pb;

            while (pa <= c[i] && pb <= c[j]) {
                int nxt = min(pos[i][pa + 1], pos[j][pb + 1]), L = min(pos[i][pa], pos[j][pb]);
                ans = (ans + (1ll * (S.sum(nxt - 1) - S.sum(cur - 1)) * T.sum(L)
                            - 1ll * (T.sum(nxt - 1) - T.sum(cur - 1)) * S.sum(L)) * (i - j)) % Mod;
                cur = nxt;
                if (pos[i][pa + 1] <= cur) ++pa;
                if (pos[j][pb + 1] <= cur) ++pb;
            }
        }
    }

    printf("%d\n", ans);

    return 0;
}

下午讲课:DP选讲

例1

一个长度为\(n\)的序列\(A\),我们称一个元素是好的,当且仅当它严格大于相邻的元素。你可以进行若干次操作,每次将一个元素减小\(1\)
对于每个\(k\in [1,\lceil\frac{n}{2}\rceil]\)求至少要进行多少次操作使得序列中至少有\(k\)个好的元素
\(n\le 5000,A_i\le 10^5\)

解:
稍作观察发现,如果最终方案中一个位置是好的,那我们一定不会对它做操作;如果不是,它最终的值是\(A_{i-1}-1,A_i,A_{i+1}-1\)中的一个

令\(dp[i][j][0]\)表示前\(i\)个元素有\(j\)个是好的,且已经钦定\(A_i\)是好的,此
时对前\(i\)个元素至少要进行的操作次数。转移到\(i+1\)时需要确保操作后\(A_{i+1}\lt A_i\)
类似地,\(dp[i][j][1/2/3]\)表示\(A_i\)不是好的时的三种情况
\(O(n^2)\)

例2

一个长度为\(n\)的序列\(A\),定义一个1到n的排列p是合法的,当且仅当\(\forall i\in[1,n-1].A_{p_i}\times A_{p_{i+1}}\)不是完全平方数
求有多少合法的排列,对\(1e9+7\)取模
\(n\le 300,A_i\le 10^9\)

解:
对于每个元素去掉它的平方质因子,问题转化为有多少排列\(p\)满足\(\forall i\in[1,n-1],A_{p_i}\ne A_{p_{i+1}}\),即相邻元素不同
先统计有多少种不同的元素,以及每种元素的个数。考虑每次将值相同的所有元素加入排列后的序列
设\(dp[i][j]\)表示已经将前\(i\)种元素加入序列,有\(j\)对相邻位置相同的方案数。转移时枚举将第\(i+1\)种元素加入后会将多少对原来不合法的相邻位置拆开,以及会新增多少不合法的相邻位置即可。
总元素个数\(O(n)\),因此复杂度最坏\(O(n^3)\)

例3

有一个长度为\(n\)的序列\(A\)和常数\(L,P\),你需要将它分成若干段,每一段的代价为\(|(\sum A_i)-L|^P\),求最小代价的划分方案

\(n\le 10^5,1\le P\le 10\)

解:
\[
dp[j]=\min_{i=0}^{j-1}|sum_j-sum_i-L|^P+dp[i]
\]
这个方程具有决策单调性,即\(\forall u\lt v\lt i\lt j\),若在\(i\)处决策\(v\)优于决策\(u\),则在\(j\)处必有\(v\)优于决策\(u\)

用一个栈维护每个决策更新的区间,新加入一个决策时可以二分得到它的区间

\(O(n\log n)\)

证明:

本题的证明需要讨论绝对值符号,先考虑里面的值为正的情况,其余的情况类似。

定义\(f_i(x)=dp[i]+(sum_x-sum_i-L)^P\),只需证明\(g(x)=f_u(x)-f_v(x),u\lt v\lt x\)单调增

也就是随着\(x\)增大决策\(u\)相较于决策\(v\)越来越不优

\[
g(x)=(sum_x-sum_u)^P-(sum_x-sum_v)^P+dp[u]-dp[v]\g'(x)=P(sum_x-sum_u)^{P-1}-P(sum_x-sum_v)^{P-1}\g'(x)\ge 0
\]

例4

一张\(n\)个点\(m\)条边的带权有向图,每条边的长度都为\(1\)。求一条最长的路径,满足边权严格递增,且路径上边的顺序与输入中这些边的相对顺序相同。

\(n,m\le 10^5\)

解:

按输入顺序考虑每一条边。设\(dp[i][j]\)表示路径到了节点\(i\),上一条边的权值\(j\)时的最长长度。

显然有用的状态是\(O(m)\)的。对每个点维护一个\(set\)来存这些状态以及它们的\(dp\)值,并保证\(dp\)值是随\(j\)递增的。这样加入一条边\((u,v)\)时,只需要在节点\(u\)的\(set\)上二分就可以进行转移了。同时还需要维护\(v\)的\(set\)。
\(O(n+m\log m)\)

例5

有一棵\(n\)个点的带权二叉树(不知道树的形态),给出对这棵二叉树进行中序遍历得到的权值序列,判断是否存在与之相符的一棵二叉树,树上每对相邻节点权值的\(gcd\)大于\(1\)

\(n\le 700,w_i\le 10^9\)

对于二叉树的一棵子树,其中序遍历是一段连续的区间。一个想法(跟昨天的题目很像)是设\(dp[l][r][i]\)表示是否能将区间\([l,r]\)建成一棵以\(i\)为根的合法二叉树,转移枚举两边子树的根,但这样的复杂度是\(O(n^5)\)

注意到对于区间\([l,r]\)构成的二叉树,除非\(l=1,r=n\),否则它一定是\(r+1\)的左子树,或者\(l-1\)的右子树。因此我们只关心根节点与\(l-1\)和\(r+1\)的权值的\(gcd\)是否为\(1\),而不需要知道根是哪个节点。

于是状态数变为\(O(n^2)\),转移仍然枚举根即可,\(O(n^3)\)

原文地址:https://www.cnblogs.com/kuaileyongheng/p/9774570.html

时间: 2024-10-21 04:36:47

雅礼学习10.6的相关文章

雅礼学习10.2

雅礼学习10.2 上午考试解题报告 各题状况(爆零) T1 想了10多分钟,暴力只有一个极大复杂度的想法,显然不可过,但还是写了,然后就全TLE也是...意料之中 T2 暴力很好写,但是错误理解了Tim给的部分分的意思:先给了一个\(a_i\le 10^9\),然后部分分里面没有提到\(a_i\)的情况,我就忽略了\(a_i\)的大小对答案统计的影响... 换句话说,我当时要是写了离散化,就是\(43\)分到手. T3 题目要求的输出可以分成三个问题,第一个问题正确 的话可以得到这个点的\(25

雅礼学习10.4

雅礼学习10.4 上午考试 各题状况 T1 莫名其妙20分了. 考场上一眼秒掉了这个题目:这不就是个并查集捆绑+快速幂么 然后开开心心这个点如果有这个质因子的话\(fa\)就指向这个质因子,而每个数字有多个质因子... 多个质因子在相互指\(fa\)的时候指乱套了.... 对拍的时候看出来的,然后用\(1\)个多小时来调这份代码,最后自己都不知道这东西在干嘛了,就凉了. T2 写了个暴力枚举,期望\(20\)实际\(20\) T3 看到成绩之后:这题怎么会爆\(long long\)的??? 然

雅礼学习10.5

雅礼学习10.5 上午考试 各题状况 T1 模拟挂成\(10\)分?? 每次更新答案的时候位置搞错了. 想到了可能是线段树动态开点,但没写出来,因为标记下传不会... T2 理解错了题目含义. 选出的\(m\)个物品中,至少要有\(k\)个是\(A\)喜欢的,至少\(k\)个是\(B\)喜欢的 那么很显然只要满足了上面的限制条件,俩人都不喜欢的也能选... 但考场上没想到这层 就凉了 正解变骗分,\(15\)分 T3 搞完上面两个题目之后没剩多少时间,就随便扔了个东西上去.. 也不知道写的是个啥

雅礼学习10.7

雅礼学习10.7 上午考试 各题状况 全TM神仙题... \(T1\) \(35\)分暴力 \(T2\) 我\(n=1\)的时候直接输出了\(1\),连这个格子上是否有方块都没判,当时是感觉...难道这个部分分也会卡么 结果出题人就这么卡了..就一分都没有了 太毒瘤了. \(T3\) 成功骗\(8\)分 做了一段时间之后去做牛客网的来着. 跟人要了份暴力 然后我TM..从紫名变成灰名了???? 题目及考场代码 T1 /* * 暴力思路:从初始位置开始进行bfs */ #include<queue

雅礼学习10.3

各题状况 T1 暴力修改+一维差分+二维差分 莫名其妙就没了49分... 好像是数组开的不够大? T2 这...概率和期望,一会不会,连那个一分的部分分都没有任何思路 T3 题目并没有看太懂.. 写了一个枚举算法,然后对某个一分的数据输出显然的结果 ... 然后就只拿了1分 枚举挂了,因为会错了题目含义 题目及考场代码 T1 /* * 一个个修改肯定超时.. * q==0的直接输出0 * 19分应该是暴力 * * 考虑对每次操作,计算一共修改了多少个位置 * 奇数个的话就让当前答案异或这个数字

#6030. 【雅礼集训 2017 Day1】矩阵

#6030. 「雅礼集训 2017 Day1」矩阵 题目描述 有一个 n×n  的矩阵,每个位置 (i,j) 如果是 . 表示为白色,如果是 # 表示为黑色. 初始时,每个位置可以是黑色或白色的,(i,j)  位置的值会作为 ai,j 给你. 现在有一种操作,选择两个整数 i,j∈[1,n],记 (i,1),(i,2),…,(i,n) (i, 1), (i, 2)的颜色为 C1,C2,…Cn ??,将 (1,j),(2,j),…,(n,j)  的颜色赋为 C1,C2,…,Cn ??. 你的任务是

2017雅礼省选集训做题记录

嘛,最近在补雅礼省选前集训的题.都是我会做的题..那一定是最水的那些题啦 题目在loj.ac上都有.过段时间如果搬了雅礼NOI集训的题应该也会做做的吧.. Day1 T1 一道经典套路题,做法跟UOJ #228基础数据结构练习题类似. 使用线段树维护.考虑相邻两个数的差值最多变化log次.也就是说,对于每个区间,只要操作二进行大概log次就能使得这个区间内所有数完全一样.所以对于操作二,只要记录一下区间最大最小值,就能直接打标记或者暴力DFS下去. 和UOJ那个题一样,注意一个特殊情况,就是一个

2018雅礼 折射

雅礼题好难啊. 这个DP题思路好强. 这个东西首先一眼就知道按y排的DP怎么写,大概就是设$f(i,j,k)$表示考虑到y坐标从大到小排名为i的点,这线上一次转是j,上上次转是k的数量,直接二维限制转移就行了. 考虑这东西怎么优化. 前缀和能搞时间,woc空间也被卡了??? 打出来表看一看???? 这个DP数组有好多都是空的... 因为越往后x限制的越少. 然后我就不会了. 正经:设$f(i,0/1)$表示从x坐标排名为i,出门左转还是右转的线的数量. 我一开始就否掉了这东西因为好像转移顺序会出

c 函数及指针学习 10

标准库函数 1算数运算stdlib.h 2随机数stdlib.h 3字符串转化stdlib.h 4数学函数 math.h 5日期和时间 time.h 6信号 signal.h 7打印可变参数列表stdarg.h 8断言 assert.h 抽象数据类型在数据结构中比较仔细 运行时环境没看 来自为知笔记(Wiz)c 函数及指针学习 10,码迷,mamicode.com