金币合成装备算法题

最新推荐文章于 2025-01-12 00:00:00 发布
最新推荐文章于 2025-01-12 00:00:00 发布
阅读量555 收藏 6
点赞数 6
文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_61738543/article/details/144137162
版权

下图是一个装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币（标注在矩形框里面），箭头上的数字表示合成所需的材料数量。比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B和装备D的合成与此类似）。

       为了简单起见，下面题目的装备图谱是一棵多叉树，而且玩家最初只拥有指定数量的叶子节点的装备，也就是图中的装备C、装备E、装备F和装备G。

       注意，下面的图谱只是一个例子，作答的时候不要局限于这个图谱。

已知玩家拥有一些初级装备（叶子节点的装备）和n个金币，并且所有装备的合成都需要消耗金币，玩家需要合成尽可能多的某个装备（记为装备X），请用C#语言计算出玩家最多可以合成出多少个装备X。

请在收到题目的一至两天内完成，提交的时候只需要提交源代码。为了规范输入输出，下面给出代码的基本结构，作答的时候不要修改Run函数的函数原型。

此题以被我写成程序啦！这里附上运行的两张图

 以下是代码：

using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.UI;

public class CountNum : MonoBehaviour
{
    public MaterialData materA, materB, materC, materD, materE, materF, materG;
    public int Ccount,Ecount, Fcount, Gcount, TotoalCoin;
    public ItemData itemDataA;
    public InputField[] inputFields;
    public Dropdown dropdown;
    public string DropdownValue = "A";
    public Text text1, text2;//1.成功合成装备件数，2.合成后剩余金币
    void Start()
    {
        inputFields[0].onValueChanged.AddListener(delegate { Ecount = int.Parse(inputFields[0].text); });
        inputFields[1].onValueChanged.AddListener(delegate { Fcount = int.Parse(inputFields[1].text); });
        inputFields[2].onValueChanged.AddListener(delegate { Ccount = int.Parse(inputFields[2].text); });
        inputFields[3].onValueChanged.AddListener(delegate { Gcount = int.Parse(inputFields[3].text); });
        inputFields[4].onValueChanged.AddListener(delegate { TotoalCoin = int.Parse(inputFields[4].text); });
        dropdown.onValueChanged.AddListener(delegate { DropdownValue = dropdown.options[dropdown.value].text; });

    }
    public class MaterialData
    {
        public ItemData item;   //合成所需的物品
        public int count;       //合成所需的该物品的数量
    }

    public class ItemData
    {
        public int id;                          //物品 ID
        public int count;                       //当前拥有的物品数量
        public int costGold;                    //合成该物品所需的金币
        public List<MaterialData> materialList; //合成该物品所需的材料
    }

    public void StartToRun()
    {
        CreatMater();
        switch (DropdownValue)
        {
            case "A":
                int n = Run(itemDataA, TotoalCoin);
                text1.text = n.ToString();
                text2.text = TotoalCoin.ToString();
                Debug.Log("最多可合成数："+n);
                break;
            case "B":
                Debug.Log("最多可合成数：" + Run(materB.item, TotoalCoin));
                break;
            case "D":
                Debug.Log("最多可合成数：" + Run(materD.item, TotoalCoin));
                break;
        }
        inputFields[0].text = "0";
        inputFields[1].text = "0";
        inputFields[2].text = "0";
        inputFields[3].text = "0";
        inputFields[4].text = "0";
    }

    /// <summary>
    /// 计算用 totalGold 金币最多可以合成的 item 装备的数量
    /// </summary>
    /// <param name="item">要合成的装备</param>
    /// <param name="totalGold">拥有的金币</param>
    /// <returns>可合成的 item 装备的最大数量</returns>
    public int Run(ItemData item, int totalGold)
    {
        TotoalCoin = totalGold;
        bool IsEasyModle = true;
        int count = item.materialList.Count;
        if (count == 0)//判断装备是否可合成
        {
            return item.count;
        }
        for (int i = 0;i< item.materialList.Count;i++)//初步判断复杂度，并且根据复杂度改变算法
        {
            if (item.materialList[i].item.costGold > 0)//若所需子物体可合成
            {
                IsEasyModle = false;
            }
        }


        if (IsEasyModle)//简易算法
        {
            int MaxCount = TotoalCoin / item.costGold;//无视基础装备数的情况下可合成的最大个数
            for (int i = 0;i<item.materialList.Count;i++)
            {
               if(item.materialList[i].item.count/ item.materialList[i] .count  <  MaxCount)//若所需物体小于最大可合成数
                {
                    MaxCount = item.materialList[i].item.count / item.materialList[i].count;
                }
            }
            TotoalCoin -= MaxCount * item.costGold;
            return MaxCount;//返回可合成item最大值
        }
        else//复杂算法
        {
            int MaxCount = 0;
            bool Isfinsh = false;
            while (!Isfinsh & TotoalCoin > item.costGold)//若总金币大于合成目前物体所需金币，开始遍历运算
            {
                for (int i = 0;i< item.materialList.Count;i++)
                {
                    if (item.materialList[i].item.count < item.materialList[i].count)//若合成一次所需物体数量不足
                    {
                        if (TotoalCoin >= item.materialList[i].item.costGold*(item.materialList[i].count - item.materialList[i].item.count) + item.costGold)//剩余金币足够合成材料费用
                        {
                            int num = item.materialList[i].count - item.materialList[i].item.count;
                            for (int x = 0;x < num; x++)//合成X个所需材料
                            {
                                
                                if (RunOneTime(item.materialList[i].item))
                                {
                                }
                                else//条件已不足以合成物体
                                {
                                    Isfinsh = true;
                                    goto end;//跳出while循环
                                }
                            }

                        }
                        else
                        {
                            Isfinsh = true;
                            goto end;//跳出while循环
                        }

                    }
                    
                    item.materialList[i].item.count -= item.materialList[i].count;
                }
                TotoalCoin -= item.costGold;
                MaxCount += 1;
            end:
                ;
            }
            return MaxCount;//返回可合成item最大值
        }





    }

    public MaterialData CreatData(int materialCount, int itemCount, int id, int costGold, params MaterialData[] materialDatas)//创建单个合成规则
    {
        MaterialData material = new MaterialData();
        material.count = materialCount;
        ItemData item = new ItemData();
        item.id = id;
        item.count = itemCount;
        item.costGold = costGold;
        item.materialList = new List<MaterialData>();
        if (materialDatas != null && materialDatas.Length > 0)
        {
            for (int i = 0; i < materialDatas.Length; i++)
            {
                item.materialList.Add(materialDatas[i]);
            }
        }
        material.item = item;
        return material;
    }

    public void CreatMater()//初始化合成规则，传入初始变量
    {
        materE = CreatData(1, Ecount, 5, -1, null);//不可合成装备，假设合成此物的金币为-1
        materF = CreatData(5, Fcount, 6, -1, null);
        materC = CreatData(1, Ccount, 3, -1, null);
        materG = CreatData(9, Gcount, 7, -1, null);
        materB = CreatData(3, 0, 2, 53, materE, materF);//合成所需金币53
        materD = CreatData(4, 0, 4, 58, materG);//合成所需金币58
        itemDataA = new ItemData();
        itemDataA.costGold = 26;
        itemDataA.id = 1;
        itemDataA.count = 0;
        itemDataA.materialList = new List<MaterialData>
        {
            materB,
            materC,
            materD
        };

    }

    public bool RunOneTime(ItemData item)
    {
        bool IsEasyModle = true;
        int count = item.materialList.Count;
        if (count == 0)//判断装备是否可合成
        {
            Debug.Log("合成上一级所需子物体不可合成哦！");
            return false;
        }

        for (int i = 0; i < item.materialList.Count; i++)//初步判断复杂度，并且根据复杂度改变算法
        {
            if (item.materialList[i].item.costGold > 0)//若所需子物体可合成
            {
                IsEasyModle = false;
            }
        }

        if (IsEasyModle)//简易算法
        {
            for (int i = 0; i < item.materialList.Count; i++)
            {
                if (item.materialList[i].item.count < 1)
                {
                    Debug.Log("合成物体所需材料不足");
                    return false;
                }
                else
                {
                    item.materialList[i].item.count -= 1;//消耗一个所需材料
                }
            }
            TotoalCoin -= item.costGold;
            item.count += 1;
            return true;
        }
        else//复杂算法
        {
            for (int i = 0; i < item.materialList.Count; i++)
            {
                if (item.materialList[i].item.count < 1)
                {
                   if(RunOneTime(item.materialList[i].item))//判断所需材料是否可以合成
                    {
                        item.materialList[i].item.count += 1;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    item.materialList[i].item.count -= 1;//消耗一个所需材料
                }
            }
            item.count += 1;
            TotoalCoin -= item.costGold;
            if (TotoalCoin >= 0)
            {
                return true;
            }
            else
            {
                return false;
            }
     
        }
    }
}

代码分为复杂算法与简易算法，当合成装备时，所需的子物体不可合成时，就直接运行下列代码进行运算，不跳入遍历进行运算：

        for (int i = 0;i< item.materialList.Count;i++)//初步判断复杂度，并且根据复杂度改变算法
        {
            if (item.materialList[i].item.costGold > 0)//若所需子物体可合成
            {
                IsEasyModle = false;
            }
        }


        if (IsEasyModle)//简易算法
        {
            int MaxCount = TotoalCoin / item.costGold;//无视基础装备数的情况下可合成的最大个数
            for (int i = 0;i<item.materialList.Count;i++)
            {
               if(item.materialList[i].item.count/ item.materialList[i] .count  <  MaxCount)//若所需物体小于最大可合成数
                {
                    MaxCount = item.materialList[i].item.count / item.materialList[i].count;
                }
            }
            TotoalCoin -= MaxCount * item.costGold;
            return MaxCount;//返回可合成item最大值
        }

 

若所合成物体较为被俄罗斯套娃了，也就是子物体可以继续合成，就进行遍历，首先进行持有金币的判断，判断是否足够完成一次遍历，若金币充足便开始计算合成，避免造成算力浪费，算法较为暴力。

 else//复杂算法
        {
            int MaxCount = 0;
            bool Isfinsh = false;
            while (!Isfinsh & TotoalCoin > item.costGold)//若总金币大于合成目前物体所需金币，开始遍历运算
            {
                for (int i = 0;i< item.materialList.Count;i++)
                {
                    if (item.materialList[i].item.count < item.materialList[i].count)//若合成一次所需物体数量不足
                    {
                        if (TotoalCoin >= item.materialList[i].item.costGold*(item.materialList[i].count - item.materialList[i].item.count) + item.costGold)//剩余金币足够合成材料费用
                        {
                            int num = item.materialList[i].count - item.materialList[i].item.count;
                            for (int x = 0;x < num; x++)//合成X个所需材料
                            {
                                
                                if (RunOneTime(item.materialList[i].item))
                                {
                                }
                                else//条件已不足以合成物体
                                {
                                    Isfinsh = true;
                                    goto end;//跳出while循环
                                }
                            }

                        }
                        else
                        {
                            Isfinsh = true;
                            goto end;//跳出while循环
                        }

                    }
                    
                    item.materialList[i].item.count -= item.materialList[i].count;
                }
                TotoalCoin -= item.costGold;
                MaxCount += 1;
            end:
                ;
            }
            return MaxCount;//返回可合成item最大值
        }

子物体缺少时会跳入子物体合成的函数中，若子物体缺少并且可合成，就再跳入合成中（有金币判断，不够钱了就停止）

 public bool RunOneTime(ItemData item)
    {
        bool IsEasyModle = true;
        int count = item.materialList.Count;
        if (count == 0)//判断装备是否可合成
        {
            Debug.Log("合成上一级所需子物体不可合成哦！");
            return false;
        }

        for (int i = 0; i < item.materialList.Count; i++)//初步判断复杂度，并且根据复杂度改变算法
        {
            if (item.materialList[i].item.costGold > 0)//若所需子物体可合成
            {
                IsEasyModle = false;
            }
        }

        if (IsEasyModle)//简易算法
        {
            for (int i = 0; i < item.materialList.Count; i++)
            {
                if (item.materialList[i].item.count < 1)
                {
                    Debug.Log("合成物体所需材料不足");
                    return false;
                }
                else
                {
                    item.materialList[i].item.count -= 1;//消耗一个所需材料
                }
            }
            TotoalCoin -= item.costGold;
            item.count += 1;
            return true;
        }
        else//复杂算法
        {
            for (int i = 0; i < item.materialList.Count; i++)
            {
                if (item.materialList[i].item.count < 1)
                {
                   if(RunOneTime(item.materialList[i].item))//判断所需材料是否可以合成
                    {
                        item.materialList[i].item.count += 1;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    item.materialList[i].item.count -= 1;//消耗一个所需材料
                }
            }
            item.count += 1;
            TotoalCoin -= item.costGold;
            if (TotoalCoin >= 0)
            {
                return true;
            }
            else
            {
                return false;
            }
     
        }
    }

需要工程的私聊我啦！

Bausei·Hu
关注
装备系统的合成-算法题
破茧
03-08 4129
这是一个公司的面试题，做个记录 下图是一个装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币（标注在矩形框里面），箭头上的数字表示合成所需的材料数量。比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B和装备D的合成与此类似）。 为了简单起见，下面两个题目的装备图谱都是一棵多叉树，而且玩家最初只拥有指定数量的叶子节点...
RPG游戏装备合成算法
幻月的博客
07-25 3382
引言 一般的手游项目中，策划挖数值坑的点来来去去就几样：装备、宠物、宝石、附魔、强化。 想让玩家爆肝怎么办？调整爆率、升级、合成、突破、进化等等 只有你想不到的，没有老八做不到的。 今天给大伙整一个俄罗斯二手的装备合成算法 为什么是二手的，因为我不是第一个发博客写这个算法的人 需求 装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币，箭头上的数字表示合成所需的材料数量。 比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B
算法题:装备合成
xyxieqing的专栏
09-28 676
你有一些合成元素对象，按指定数量的类型的合成元素可以合成一些装备，合成时候会有一些费用，合成的装备可以卖出，合成元素本身可以卖出。合成一个装备后，剩余元素个数只要还够合成，可以继续合成，也可以选择不合成。 要求所有东西卖出后收入最大化。 一个现实业务精简来的问题，背包、规划或自己的思路都可以。你试一试吧。...
【算法】装备合成（二分）
littlegengjie的博客
11-27 872
来源：牛客网。
装备合成
qq_35975367的博客
05-01 505
链接： 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 输入描述: 输入包含t组数据 第一行一个整数t 接下来{t}t行每行两个整数x,y 输出描述: 每组数据输出一行一个整数表示答案。 示例1 输入 复制 5 4 8 7 6 8 10 100 4555 45465 24124 输出...
牛客算法周周练4 E题装备合成——三分搜索
彤云望月
04-29 294
链接 ：装备合成 题意 ： 思路 ：控制变量 设 方法一生成的装备数量为 m，则方法二生成的装备数量是 min((x - 2 * m)/4, y - 3* m)。 所以生成的总量函数 f(m) = m + min((x - 2 * m)/4, y - 3* m)。 m 的范围是 [0, min(x/2,y/3) ] ，即使用方法一生成的个数。而直接线性维护此函数的极值，复杂度最高是 1e9/...
已知玩家拥有一些初级装备（叶子节点的装备）和n个金币，并且所有装备的合成都需要消耗金币，玩家需要合成尽可能多的某个装备（记为装备X），请用C#语言计算出玩家最多可以合成出多少个装备X。
05-22
// 合成装备 int total = 0; bool flag = true; while (flag) { flag = false; foreach (Equipment e in equipments) { if (e.cost (e.name)) { int num = Math.Min((coins / e.cost), (e.target - counts[e...
MMORPG游戏装备系统开发技术总结
最新发布
小宝哥Code的专栏
01-12 703
装备系统是MMORPG（大规模多人在线角色扮演游戏）中的核心系统之一，它直接影响玩家的游戏体验、角色成长、战斗能力、经济系统和玩家互动。装备系统的设计和开发不仅需要考虑功能性，还需要关注平衡性、可扩展性、性能和用户体验等方面。以下是MMORPG游戏装备系统的开发技术总结。
【二分答案+线性规划】装备合成
weixin_62528401的博客
10-15 617
二分
装备合成求最大可合成数量算法题
weixin_53088153的博客
09-14 565
中分别需要的每个叶子结点的count数量,最后根据当前每个叶子结点拥有的item.count数量，求出真正的。1.暴力穷举法，穷举合成过程得出结果，时间代价较大，数据量大时不可取。以下我提供2种解题代码：（该问题主要还是要对树作遍历）代价求出当前拥有的金币最多。2.枚举优化算法，①先按。可以合成的目标装备数量。可以合成的目标装备数量。可以合成的目标装备数量。不允许修改Run函数。
ACM题--C-装备合成问题
qq_40314362的博客
03-30 647
简介 参考大佬解题解题代码来理解着题的， [大佬传送门](https://blog.youkuaiyun.com/weixin_43872728/article/details/104858125) 题目描述 牛牛有x件材料a和y件材料b，用2件材料a和3件材料b可以合成一件装备，用4件材料a和1件材料b也可以合成一件装备。牛牛想要最大化合成的装备的数量，于是牛牛找来了你帮忙 输入描述 输入包含t组数...
装备合成 三分
RunningBeef的博客
02-17 475
题目链接 牛牛有x件材料a和y件材料b，用2件材料a和3件材料{b}b可以合成一件装备，用4件材料a和1件材料b也可以合成一件装备。牛牛想要最大化合成的装备的数量，于是牛牛找来了你帮忙。 三分算法学习链接 转至(https://www.cnblogs.com/techflow/p/12131376.html) 很多题解都是用的三分，但没有说明为什么可以用3分，也就是没有证明答案是一个凸函数，或者凹函数 证明 设:以2a,3b方式合成的装备有m件 以4a,b方式合成的装备有n件 m取.
软件项目管理3：开源,装备合成功能的多种方案
钢七连软件项目管理和开发
11-23 801
基于原有的飞机大战，用树状结构完成装备的合成，绘制合成路径。功能还可以再改进。 比如：设计模式的组合模式。 用抽象组件、复合节点、叶子节点，表示装备关系。 1. 表示装备的节点关系 2. 判断当前物品是否达到某个装备的合成条件 还可以生成一张表格：某个装备可以生成哪些装备 然后是装备的属性设置。 只有装备带来不同的属性变化，才有应用意义。 虽然一款对战游戏看起来很多战斗，不过是三种...
设计模式7：开源, 游戏装备合成
钢七连软件项目管理和开发
11-22 1579
一个仿王者荣耀的装备合成系统，运行效果：    最关键的是这两个数组： public static int conditionAr[][]=new int[][]{         {80,-1,-1,-1},         {100,-1,-1,-1},         {100,-1,-1,-1},                  {200,0,1,-1},         {2...
游戏合成装备算法面试题
Happinessคิดถึง的博客
09-14 2371
** 更新时间：2020-09-14 ** 最近很多游戏公司来招聘，下面给出面试到的算法题。 我也不懂，为啥这么多游戏公司缺人。 而且我也没做过游戏方面啊！！！！ 面试内容： 下图是一个装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币（标注在矩形框里面），箭头上的数字表示合成所需的材料数量。比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B和装备D的合成与此类似）。 为了简单起见，下面题目的装备图谱都是一棵多叉树，而且玩家
装备合成系统（最大限度地合成目标装备）
eleven_mie的博客
08-03 3551
题目 下图是一个装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币（标注在矩形框里面），箭头上的数字表示合成所需的材料数量。比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B和装备D的合成与此类似）。 为了简单起见，下面题目的装备图谱都是一棵多叉树，而且玩家最初只拥有指定数量的叶子节点的装备，也就是图中的装备C、装备E、装备F和装备G。 注意，下面的图谱只是一个例子，作答的时候不要局限于这个图谱。 已知玩家拥有一些初级装备
前端面试题
weixin_33950757的博客
06-16 1070
下图是一个装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币（标注在矩形框里面），箭头上的数字表示合成所需的材料数量。比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B和装备D的合成与此类似）。 为了简单起见，下面两个题目的装备图谱都是一棵多叉树，而且玩家最初只拥有指定数量的叶子节点的装备，也就是图中的装备C、装备E、装备F和装备G。 注意，下面的图谱只是一个例子，作答的时候不要局限于这个图谱。 请从下面的题目中选择一个来
装备合成（三分）
moyangxian
06-03 321
链接：https://ac.nowcoder.com/acm/problem/200211 来源：牛客网 题目描述 牛牛有{x}x件材料{a}a和{y}y件材料{b}b，用{2}2件材料{a}a和{3}3件材料{b}b可以合成一件装备，用{4}4件材料{a}a和{1}1件材料{b}b也可以合成一件装备。牛牛想要最大化合成的装备的数量，于是牛牛找来了你帮忙。 输入描述: 输入包含{t}t组数据 第一行一个整数{t}t 接下来{t}t行每行两个整数{x,y}x,y 输出描述: 每组数据输出一行一个整数表示答案。
一道游戏开发的算法题
m0_61188201的博客
06-06 302
下图是一个装备系统的合成图谱，箭头指向的是合成之后的装备，每合成一个装备需要消耗一些金币（标注在矩形框里面），箭头上的数字表示合成所需的材料数量。比如，要合成n个装备A，需要消耗3n个装备B、1n个装备C、4n个装备D，而且还需要消耗26n金币（装备B和装备D的合成与此类似）。已知玩家拥有一些初级装备（叶子节点的装备）和n个金币，并且所有装备的合成都需要消耗金币，玩家需要合成尽可能多的某个装备（记为装备X），请用C#语言计算出玩家最多可以合成出多少个装备X。为了简单起见，下面题目的装备图谱是。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值