精华内容
下载资源
问答
  • 每次形dp时改动一下,递归子树时去掉一份下一个节点的花费,强制选择下一个节点一次,这样就是选择一个联通块了,每次背包二进制分解一下,再用点分治优化即可。 #include <cstdio> #include &...

    Description:
    树上每个点有容量,花费,价值。你有mm元钱,问选出一个连通块的最大价值。


    Solution:
    问题在于必须选出一个连通快。每次树形dp时改动一下,递归子树时去掉一份下一个节点的花费,强制选择下一个节点一次,这样就是选择一个联通块了,每次背包二进制分解一下,再用点分治优化即可。


    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <vector>
    using namespace std;
    const int N = 505;
    int n, m, root, ans;
    vector<int> G[N];
    int vis[N], mx[N], sz[N], w[N], c[N], d[N], dp[N][4005];
    int getsize(int u, int last) {
        int ret = 1;
        for(int i = 0; i < G[u].size(); ++i) {
            if(G[u][i] != last && !vis[G[u][i]]) {
                ret += getsize(G[u][i], u);
            }
        }
        return ret;
    }
    void findroot(int u, int last, int S) {
        mx[u] = 0;
        sz[u] = 1;
        for(int i = 0; i < G[u].size(); ++i) {
            int v = G[u][i];
            if(v != last && !vis[v]) {
                findroot(v, u, S);
                sz[u] += sz[v];
                mx[u] = max(mx[u], mx[v]);
            }
        }
        mx[u] = max(mx[u], S - sz[u]);
        if(mx[u] < mx[root]) {
            root = u;
        }
    }
    void dfs(int u, int last, int m) {
        if(m <= 0) {
            return;
        }
        for(int i = 0, j = d[u]; j; ++i) {
            if(j >= (1 << i)) {
                for(int W = c[u] << i, V = w[u] << i, k = m; k >= W; --k) {
                    dp[u][k] = max(dp[u][k], dp[u][k - W] + V);
                }
                j -= 1 << i;
            } else {
                for(int W = c[u] * j, V = w[u] * j, k = m; k >= W; --k) {
                    dp[u][k] = max(dp[u][k], dp[u][k - W] + V);
                }
                j = 0;
            }
        }
        for(int i = 0; i < G[u].size(); ++i) {
            int v = G[u][i];
            if(v != last && !vis[v]) {
                for(int j = 0; j <= m - c[v]; ++j) {
                    dp[v][j] = dp[u][j];
                }
                dfs(v, u, m - c[v]);
                for(int j = c[v]; j <= m; ++j) {
                    dp[u][j] = max(dp[u][j], dp[v][j - c[v]] + w[v]);
                }
            }
        }
    }
    void solve(int u) {
        root = 0;
        findroot(u, 0, getsize(u, 0));
        vis[root] = 1;
        memset(dp[root], 0, sizeof(dp[root]));
        dfs(root, 0, m - c[root]);
        for(int i = 0; i <= m - c[root]; ++i) {
            ans = max(ans, dp[root][i] + w[root]);
        }
        for(int i = 0; i < G[root].size(); ++i) {
            if(!vis[G[root][i]]) {
                solve(G[root][i]);
            }
        }
    }
    int main() {
        int T;
        scanf("%d", &T);
        mx[0] = 0x3f3f3f3f;
        while(T--) {
            ans = 0;
            scanf("%d%d", &n, &m);
            for(int i = 1; i <= n; ++i) {
                G[i].clear();
                vis[i] = 0;
                scanf("%d", &w[i]);
            }
            for(int i = 1; i <= n; ++i) {
                scanf("%d", &c[i]);
            }
            for(int i = 1; i <= n; ++i) {
                scanf("%d", &d[i]);
                --d[i];
            }
            for(int i = 1; i < n; ++i) {
                int u, v;
                scanf("%d%d", &u, &v);
                G[u].push_back(v);
                G[v].push_back(u);
            }
            solve(1);
            printf("%d\n", ans);
        }
        return 0;
    }
    展开全文
  • 提出一种结合最优缩放框架与四叉分割的图像编码算法,在对图像进行无缩放因子的整数小波分解后,各子带仅乘一次缩放因子,降低了变换的计算复杂度。在编码过程中,利用新的四叉分割框架提高重要系数的搜索效率。...
  • /* 的分治 因为的点权值可达到10^15,注意手动扩栈,还有int64 题意:给你一棵,给你一些素数,给你每个...由立方数的性质可得,一个数可有素数组成,对于这些素数可以分解为这些素数相乘的形式如,24=(2^3)*(3...
    /*
    树的分治
    因为树的点权值可达到10^15,注意手动扩栈,还有int64
    题意:给你一棵树,给你一些素数,给你每个点一个权值且每个权值均可由这些素数组成。现在定义任意任意两点的价值为他们路径上的权值相乘。求这样的点对的权值为立方数的个数
    解:
    如果直接求得话会超int64,不可行
    由立方数的性质可得,一个数可有素数组成,对于这些素数可以分解为这些素数相乘的形式如,24=(2^3)*(3^1);如果是立方数的话那么他的各进制对3取余都为0.股24可写成01这种三进制形式
    对于这些权值的乘法可有三进制想加可得。
    接下来就是树的分治了
    当然这里可以先求出一条子树上的各个点的权值乘积,然后和根节点和其他字树比较看是否可以互补那么就找到一对
    可用map容器实现。因为他重点是比较到根节点和其他子树是否可以互补,进而递归下去,求出每个子树的这样的点对。
    */
    #pragma comment(linker, "/STACK:1024000000,1024000000")
    #include<stdio.h>
    #include<string.h>
    #include<algorithm>
    #include<iostream>
    #include<map>
    #define ll  __int64
    #define N 51000
    #define inf 0x3fffffff
    using namespace std;
    struct node {
     ll u,v,next;
    }bian[N*4];
    ll yong,head[N];
    ll num[N],nn,all[N][51],ff[N][51],minn,m,vis[N],fp[N],ma;
    ll prime[51],len;
    map<ll,ll>q;
    void init() {
     yong=0;
     memset(head,-1,sizeof(head));
    }
    void addedge(ll u,ll v) {
    bian[yong].u=u;
    bian[yong].v=v;
    bian[yong].next=head[u];
    head[u]=yong++;
    }
    void dfs1(ll u,ll fa) {//找到每次根子树的的节点数目
        ll i;
        nn++;
        for(i=head[u];i!=-1;i=bian[i].next) {
            ll v=bian[i].v;
            if(v!=fa&&!vis[v])
                dfs1(v,u);
        }
        return ;
    }
    ll Max(ll v,ll vv) {
    return v>vv?v:vv;
    }
    void dfs2(ll u,ll fa) {//找重心
     num[u]=1;
     ll i,tit=0;
     for(i=head[u];i!=-1;i=bian[i].next) {
        ll v=bian[i].v;
        if(v!=fa&&!vis[v]) {
            dfs2(v,u);
            num[u]+=num[v];
            tit=Max(tit,num[v]);
        }
     }
     tit=Max(tit,nn-num[u]);
     if(tit<minn) {
        minn=tit;
        ma=u;
     }
     return ;
    }
    void dfs4(ll u,ll fa) {
     ll i;
     //prllf("dfs4=%d",u);
     if(fa!=-1) {
            ll  e=fp[fa];
        for(i=1;i<=m;i++)
            all[len][i]=(all[e][i]+ff[u][i])%3;
     }
     else {
        for(i=1;i<=m;i++)
            all[len][i]=ff[u][i];
     }
     fp[u]=len++;
     for(i=head[u];i!=-1;i=bian[i].next) {
        ll v=bian[i].v;
        if(v!=fa&&!vis[v])
            dfs4(v,u);
     }
     return ;
     }
    ll dfs3(ll u) {//求以当前子树为根的符合条件的对数
       ll i,ans=0,j,k;
       ll s1,s2;
       s1=0;
       q.clear();
       for(i=1;i<=m;i++)
        s1=s1*3+ff[u][i];
      if(s1==0)ans++;
       //prllf("ma=%d,s1=%d\n",ma,s1);
        q[s1]=1;
        for(i=head[u];i!=-1;i=bian[i].next) {
            ll v=bian[i].v;
            if(vis[v])continue;
            len=0;
            dfs4(v,-1);
         //  prllf("len=%d\n",len);
            for(j=0;j<len;j++) {//进行互补
                s1=0;
                for(k=1;k<=m;k++)
                    s1=s1*3+(3-all[j][k])%3;
            //  prllf("zzs1=%d\n",s1);
                    ans+=q[s1];
            }
            for(j=0;j<len;j++) {
                s2=0;
                for(k=1;k<=m;k++)
                    s2=s2*3+(all[j][k]+ff[u][k])%3;//到根结点的权值,为下次互补做准备,同时避免重复
                q[s2]++;
            }
          //  prllf("aad%d\n",ans);
        }
        return ans;
    }
    ll dfs(ll u) {
      minn=inf;
      nn=0;
      dfs1(u,-1);
      dfs2(u,-1);//求重心
      vis[ma]=1;
      ll ans=dfs3(ma);
     // prllf("ma=%d\n",ma);
      //prllf("ans=%d\n",ans);
      ll i;
      for(i=head[ma];i!=-1;i=bian[i].next) {
        ll v=bian[i].v;
        if(!vis[v])
            ans+=dfs(v);
      }
      return ans;
    }
    int main() {
          ll n,i,j,k,kk;
          while(scanf("%I64d",&n)!=EOF) {
           init();
           scanf("%I64d",&m);
           for(i=1;i<=m;i++)
            scanf("%I64d",&prime[i]);
           for(i=1;i<=n;i++) {
            scanf("%I64d",&k);
              for(j=1;j<=m;j++) {
                kk=0;
                while(k%prime[j]==0) {
                    k/=prime[j];
                    kk++;
                    kk%=3;
                }
                ff[i][j]=kk;
              }
           }
           for(i=1;i<n;i++) {
            scanf("%I64d%I64d",&j,&k);
            addedge(j,k);
            addedge(k,j);
           }
           memset(vis,0,sizeof(vis));
           printf("%I64d\n",dfs(1));
          }
    return 0;}
    

    转载于:https://www.cnblogs.com/thefirstfeeling/p/4410595.html

    展开全文
  • 思路:扫描线的陈题,先线段的功能,区间价值,维护的是区间上的最大值,然后将每个敌方单位分解成两个事件,不断更新就行。 code: #include #include #include #include #include using namespace ...

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5091

    思路:扫描线的陈题,先线段树的功能,区间价值,维护的是区间上的最大值,然后将每个敌方单位分解成两个事件,不断更新就行。


    code:

    #include <cstdio>
    #include <cstdlib>
    #include <iostream>
    #include <cstring>
    #include <algorithm>
    
    using namespace std;
    
    const int maxn=70050;
    const int maxt=30500;
    const int mo=20005;
    
    struct sg_tree
    {
        int l,r;
        int col,rmax;
    } ss[maxn<<2];
    
    struct Thing
    {
        int l,r,y,kind;
    } P[maxt];
    
    int n;
    int nn,w,h,ta;
    
    void Push_up(int k)
    {
        ss[k].rmax=max(ss[(k<<1)+1].rmax,ss[(k<<1)+2].rmax);
    }
    void Push_down(int k)
    {
        ss[(k<<1)+1].col+=ss[k].col;
        ss[(k<<1)+2].col+=ss[k].col;
        ss[(k<<1)+1].rmax+=ss[k].col;
        ss[(k<<1)+2].rmax+=ss[k].col;
        ss[k].col=0;
    }
    void Build(int k,int l,int r)
    {
        ss[k].col=0;
        ss[k].rmax=0;
        ss[k].l=l;
        ss[k].r=r;
        if(r==l) return ;
        Build((k<<1)+1,l,(l+r)/2);
        Build((k<<1)+2,(l+r)/2+1,r);
    }
    void init(int nn)
    {
        n=1;
        while(n<nn) n*=2;
        Build(0,0,n-1);
    }
    void update(int a,int b,int k,int cc)
    {
        if(b<ss[k].l||a>ss[k].r) return ;
        if(a<=ss[k].l&&ss[k].r<=b){
            ss[k].col+=cc;
            ss[k].rmax+=cc;
        }
        else{
            int mid=(ss[k].l+ss[k].r)/2;
            Push_down(k);
            update(a,b,(k<<1)+1,cc);
            update(a,b,(k<<1)+2,cc);
            Push_up(k);
        }
    }
    int query(int a,int b,int k)
    {
        if(a<=ss[k].l&&ss[k].r<=b) return ss[k].rmax;
        else{
            int v1,v2;
            v1=v2=0;
            int mid=(ss[k].l+ss[k].r)/2;
            if(a<mid) v1=query(a,b,(k<<1)+1);
            if(b>mid) v2=query(a,b,(k<<1)+2);
            return max(v1,v2);
        }
    }
    
    bool cmp(Thing A,Thing B)
    {
        if(A.y==B.y) return A.kind<B.kind;
        return A.y<B.y;
    }
    
    //最佳的放置状态下 矩阵的一边肯定是和每个节点重合
    //我们假设左边是和敌人节点重叠的
    //那么对每个敌方单位他能被包含的区域就是x+w
    //对于每个敌方单位我们构造两种事件 l,r都为x和x+w y为y和y+h+1 kind分别为1和-1
    //然后把所有事件按y的坐标排序 一次进行执行即可
    //每次执行后都用根节点的值来更新res
    void creat(int x,int y)
    {
        x+=mo; y+=mo;
        P[ta].l=x; P[ta].y=y;
        if(x+w<=50000) P[ta].r=x+w;
        else P[ta].r=50000;
        P[ta++].kind=1;
    
        P[ta].l=P[ta-1].l;
        P[ta].r=P[ta-1].r;
        if(y+h+1<=50000) P[ta].y=y+h+1;
        else P[ta].y=50000;
        P[ta++].kind=-1;
    }
    
    int main()
    {
        int x,y,res;
        while(scanf("%d",&nn),nn>=0){
            scanf("%d%d",&w,&h);
            res=ta=0;
            for(int i=0;i<nn;i++){
                scanf("%d%d",&x,&y);
                creat(x,y);
            }
            init(50005);
            sort(P,P+ta,cmp);
            //for(int i=0;i<ta;i++){
               // printf("l=%d r=%d y=%d kind=%d\n",P[i].l,P[i].r,P[i].y,P[i].kind);
           // }
            for(int i=0;i<ta;i++){
                update(P[i].l,P[i].r,0,P[i].kind);
                res=max(res,ss[0].rmax);
            }
            printf("%d\n",res);
        }
        return 0;
    }


    展开全文
  • 与此同时,与用户-项目交互相关的丰富的侧信息(例如,用户统计数据和项目属性)提供了有价值的证据,说明为什么推荐适合于用户,但在提供解释方面还没有得到充分的探索。 在技术方面,基于嵌入的方法,例如广泛和...

    摘要:

    虽然协同过滤是个性化推荐的主流技术,但它只对用户-项目交互进行建模,不能为推荐提供具体的理由。与此同时,与用户-项目交互相关的丰富的侧信息(例如,用户统计数据和项目属性)提供了有价值的证据,说明为什么推荐适合于用户,但在提供解释方面还没有得到充分的探索。

    在技术方面,基于嵌入的方法,例如广泛和深入的神经因子分解机,提供最先进的推荐性能。然而,它们的工作原理就像一个黑匣子,预测背后的原因无法明确地呈现出来。另一方面,决策树等基于树的方法通过从数据中推断决策规则来进行预测。虽然可以解释,但它们不能推广到不可见的特性交互,因此在协作过滤应用程序中会失败。在这项工作中,我们提出了一个新的解决方案,称为树增强嵌入方法结合了基于嵌入和基于树的模型的优点。我们首先使用一个基于树的模型来学习明确的决策规则(交叉特征)来自丰富的侧面信息。接下来,我们设计了一个嵌入模型,该模型可以包含显式交叉特征,并推广到用户ID和项目ID上不可见的交叉特征。嵌入方法的核心是一个易于解释的注意力网络,使得推荐过程完全透明和可解释。我们对旅游景点和餐厅推荐两个数据集进行了实验,证明了我们的解决方案的优越性能和可解释性。

    相关工作:

    我们大致可以将解释风格分为基于相似性和基于内容的类别。基于相似性的方法以最相似的用户或项目列表的形式给出解释。例如,Behnoush等人的使用限制玻尔兹曼机来计算top-K推荐列表中项目的可解释性得分。虽然基于相似性的解释可以作为解释CF推荐的通用解决方案,但缺点是它缺乏具体的推理。基于内容的作品考虑了各种侧面信息,从项目标签[38,40]、社会关系[31,37]、用户的上下文评论[13,15,28,31,48]到知识图谱,

    结论:

    本文提出了一种树增强嵌入方法(TEM),它无缝地结合了基于嵌入模型的泛化能力和基于树的模型的可解释性。由于基于树的部分具有明显的交叉特征和易于解释的注意网络,我们的解决方案的整个预测过程是完全透明和自解释的。同时,TEM
    可以达到与目前最先进的推荐方法相媲美的性能。在未来,我们将把TEM扩展到三个方向。首先,我们尝试联合学习基于树和基于嵌入的模型,而不是分别对两个组件建模。这可以促进两个组件之间的信息传播。其次,我们考虑其他上下文信息,如时间、位置和用户情绪,以进一步丰富我们的解释能力。第三,我们将探讨将知识图和逻辑规则引入TEM的有效性

    以下是自己的理解,欢迎指错。

    1.CF利用user-item的历史交互记录,来计算用户或用户的相似性,从而进行top-k推荐,但放弃了其他额外的信息。在解释性方面,推荐的原因仅仅是你的朋友也喜欢,或者是和你购买的东西很相似,这是不足以让人信服的。

    • 解决的问题:增强推荐可解释性的同时,增强推荐的准确度。
    • 提出的模型:TEM = tree + embedding , 基于embedding的方法具有较强的泛化能力,但一旦额外信息丰富就会失去可解释性。基于tree的方法,既可以做到显性预测,生成的交叉特征可直接解释,但对于未观察到的数据是不能预测。                 在TEM中,有两大重要部分,embedding和attention,embedding向量用于捕获交叉特征之间的相关性,使用GDBT和基于嵌入的协同过滤,把交叉特征投影到嵌入向量中;attetion具体模拟交叉特征的个性化权重,使用的是多层感知器MLPs。
    • 具体方案:TEM 由两个模型组成,首先(explicity),利用GBDT在额外信息上有效地区分交叉特征,然后(explainable),将最有预测能力的交叉特征输入到一个基于嵌入的模型,该模型是neural attention network,根据预测对交叉特征重新加权。在tree中,每条path可看做一个交叉特征,叶子结点可看做这条path的预测值。GBDT梯度增强决策树,通过增加树 的数量来增强预测。后期,根据用户反馈,可以局部修改交叉特征,并修改相应的注意力权重,从而不用重新训练模型,就可以更新预测,并重排推荐列表。

     

    展开全文
  • 1. 为了实现产品思维,必须从传统的项目型交付方式转变为产品型研发。2. 将工作从精益价值树LVT分解为产品蓝图,再关联至敏捷产品的待办列表。在战略和执行之间建立流程和一致性,同时将领导...
  • 引入数据挖掘思想,采用邻域粗糙集构造贪心式属性约简算法进行属性约简,将约简后的属性集输入所设计的C4.5决策算法,经过训练,其诊断准确率达到98%。研究结果表明:该方法能够实现液体电磁阀的快速诊断,具有...
  • 这篇文章主要为大家详细介绍了iOSiOS核心动画:图层...Core Animation是一个复合引擎,它的职责就是尽可能快地组合屏幕上不同的可视内容,这个内容是被分解成独立的图层,存储在一个叫做图层的体系之中。于是这个.
  • 专门讲述如何挖掘和分析Web上的数据和资源,如何分析用户体验、市场营销、个人品味等诸多信息,并得出有用的结论,通过复杂的算法来从Web网站获取、收集并分析用户的数据和反馈信息,以便创造新的用户价值和商业价值...
  • 上下文与社交网络信息已经被证实对建立精确的推荐系统有重要的价值。然而,据我们所知,目前不存在有系统地结合这些信息去提高推荐质量的研究。在这篇论文中,我们提出SoCo,一个新颖的将精心处理社交网络信息的上...
  • 推荐系统调研

    2020-08-18 17:00:14
    推荐系统的目的: 快速定位用户兴趣点,...常用算法:逻辑回归(Logistics Regression)、梯度提升决策(GBDT)和因式分解(FM) 面向深度学习的推荐系统架构设计 场景:图像处理、自然语言理解、语音识别、在线
  • 针对故障诊断面临的故障样本少、非线性强、多故障处理等问题以及传统智能诊断方法存在的不足,提出了一种基于决策(DT)和相关向量机(RVM)的智能故障诊断方法。通过构造决策二叉树,将多类分类问题分解成多个二...
  • 以太坊白皮书

    2021-02-01 02:51:53
    下一代智能合约和去中心化应用平台历史作为状态转换系统的比特币挖矿默克尔其它的区块链应用脚本以太坊以太坊账户消息和交易以太坊状态转换函数代码执行区块链和挖矿应用令牌系统金融衍生品和价值稳定的货币身份和...
  • 2020-08-21

    2020-08-21 17:02:38
    构建计算逻辑4.快速计算结果总结 一、费米问题是什么? 在科学中,尤其是在物理和工程教育中,费米问题(Fermi problem)或费米估算是一个用来做量纲分析,估算和清晰地验证一个假设的估算问题。命名自恩里科·...
  • xx市西区国家税务局精神文明建设按照市局、西区区委、政府提出的要求,紧紧抓住建设社会主义核心价值体系这个根本,以“讲文明、新风”、同在一方热土、共建美好家园为载体,加强思想道德建设和单位精神文明创建...
  • 本丛书适用于参加ACM国际大学生程序设计竞赛的本科生和研究生,对参加青少年信息学奥林匹克竞赛的中学生也很有指导价值。同时,作为程序设计、数据结构、算法等相关课程的拓展与提升,本丛书也是难得的教学辅助读物...
  • 其一,充分提高时间效益,切实落实好工作时志表,充分利用好每一秒钟的时间,只有保证每秒,每分,每时,每天的工作效益,才能保证个人价值。其二,实行目标分解,任务到人,通过绩效评估找到差距。每个岗?..
  • 本书的组织结构清晰且易于理解,强调了创造性,具有浓郁特色,时至今日仍有其巨大的价值,并且适合作为计算机及相关专业算法和高级算法课程的教材。 第1章 引论 第2章 数学归纳法 2.1 引言 2.2 三个简单的例子 ...
  • 5.5 质因子分解 165 5.6 大整数运算 170 5.6.1 大整数的存储 170 5.6.2 大整数的四则运算 171 5.7 扩展欧几里得算法 176 5.8 组合数 181 5.8.1 关于n!的一个问题 181 5.8.2 组合数的计算 183 第6章 C++标准模板库...
  •  本书是高等院校计算机及相关专业本科生数据库系统课程的理想教材,也是对相关技术人员非常有价值的参考书。 作译者  Ramez elmasri是世界知名的数据库学者。现任得克萨斯大学职灵顿分校计算机科学与工程系教授...
  • 本课程的目的是对学生进行系统的马克思主义理论教育,帮助学生掌握马克思主义的世界观和方法论,树立马克思主义的人生观和价值观,学会用马克思主义的世界观和方法论观察和分析问题,培养和提高学生运用马克思主义...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    本项目是一个能提高用户参与和娱乐程序的项目,具有一定的使用价值。 追求的结果--钢琴练奏师 1.2 项目背景 传统的音乐播放器功能单一,用户对音乐缺少参与感,本项目志在提高用户对音乐的学习和娱乐,参与创作...
  • 26.关于目标分解完成 27.关于大学毕业后差距 28.关于人格破产这回事 29.关于看书提升能力 30.关于打造自己世界 31.关于撩和追的区别 32.关于知识付费学习 33.关于修养与教养 34.关于如何看待加班 35.关于经济独立 36...
  • 软件工程知识点

    2012-12-02 21:34:25
    它使用矩形来表示系统中的子系统或功能模块,使用形连线结构来表达系统所具有的功能层级关系。 (2)数据流模型。用于描述系统对数据的加工过程,其图形符号是一些具有抽象意义的逻辑符号,主要的图形符号包括:...
  •  本书是高等院校计算机及相关专业本科生、研究生数据库系统课程的理想教材,也是对相关技术人员非常有价值的参考书。 作译者  Ramez elmasri是世界知名的数据库学者。现任得克萨斯大学职灵顿分校计算机科学与工程...
  • 学习Oracle时,很多书和资料都很有参考价值,特别是Oracle文档,更是全面地提供了我们想了解的信息。但是文档中没有实战用例,没有告诉我们哪些可行或者哪些不可行,什么情况下可行或者什么情况下不可行,为什么可行...
  • 说明:目前,数据分析是一个非常热门的方向,因为不管是互联网行业还是传统行业都已经积累了大量的数据,现在需要的就是从这些数据中提取有价值的信息,以便打造更好的产品或者为将来的决策提供支持。 给初学者的几...
  • 而在章的内部,一项大的功能被分解成许多小的步骤,通过完成每个小的步骤,读者可以不断获得阶段性的成果,从而让整个开发过程变得轻松并且有趣。 本书适合各类程序员、程序开发爱好者阅读,也可作为高等院校操作...
  • 而在章的内部,一项大的功能被分解成许多小的步骤,通过完成每个小的步骤,读者可以不断获得阶段性的成果,从而让整个开发过程变得轻松并且有趣。 本书适合各类程序员、程序开发爱好者阅读,也可作为高等院校操作...

空空如也

空空如也

1 2
收藏数 31
精华内容 12
关键字:

价值树分解