精华内容
下载资源
问答
  • 无优先级运算问题
    千次阅读
    2007-04-26 13:28:18

     

    1.问题描述

    给定n个正整数和4个运算符+,-,*,/,且运算符无优先级,如2+3*5=25。对于任意给定的整数m,是设计一个算法,用以上给出的n个数和4个运算符,产生整数m,且用的运算次数最少。给出的n个树中的每个数最多只能用1次,但每种运算符可以任意使用。

    2.编程任务

        对于给定的n个整数,采用回溯方法来设计一个算法,用最少的无优先级运算次数产生整数m。

    更多相关内容
  • 无优先级运算问题

    2015-06-03 11:32:31
    问题描述: 给定 n 个正整数和 4 个运算符+、-、∗、/,且运算符优先级,如 2+3∗5=25。对于 任意给定的整数 m,试设计一个算法,用...对于给定的 n 个正整数,设计一个算法,用最少的无优先级运算次数产生整数 m。
  • 5-18 无优先级运算问题 问题描述 给定 n 个正整数和 4 个运算符+、-、*、/,且运算符优先级,如 2+3*5=25。对于任意给定的整数 m,试设计一个算法,用以上给出的 n 个数和 4 个运算符,产生整数 m, 且用的...

    5-18 无优先级运算问题


    问题描述

    给定 n 个正整数和 4 个运算符+、-、*、/,且运算符无优先级,如 2+3*5=25。对于任意给定的整数 m,试设计一个算法,用以上给出的 n 个数和 4 个运算符,产生整数 m, 且用的运算次数最少。给出的 n 个数中每个数最多只能用 1 次,但每种运算符可以任意使用。

    对于给定的 n 个正整数,设计一个算法,用最少的无优先级运算次数产生整数 m。

    数据输入:
    第一行有 2 个正整数 n 和 m。第 2 行是给定的用于运算的 n 个正整数。


    Java

    package Chapter5HuiSuFa;
    
    import java.util.Scanner;
    
    public class WuYouXianJiYunSuan {
    
        private static int n,m,k;
        private static int[] a,num,oper;
        private static boolean[] used;
    
        public static void main(String[] args){
            Scanner input = new Scanner(System.in);
    
            while (true){
                n = input.nextInt();
                m = input.nextInt();
    
                a = new int[n];
                num = new int[n];
                oper = new int[n];
                used = new boolean[n];
    
                for(int i=0; i<n; i++){
                    a[i] = input.nextInt();
                    used[i] = false;
                }
    
                for(k=0; k<n; k++){
                    if(search(0)){
                        System.out.println(k);
                        out();
                        return;
                    }
                }
    
                System.out.println("No Solution!");
            }
        }
    
        private static boolean search(int dep){
            if(dep > k){
                if(found()) return true;
                else return false;
            }
            for(int i=0; i<n; i++)
                if(!used[i]){
                    num[dep] = a[i];
                    used[i] = true;
                    for(int j=0; j<4; j++){
                        oper[dep] = j;
                        if(search(dep+1))
                            return true;
                    }
                    used[i] = false;
                }
    
            return false;
        }
    
        private static boolean found(){
            int x = num[0];
            for(int i=0; i<k; i++){
                switch (oper[i]){
                    case 0: x += num[i+1]; break;
                    case 1: x -= num[i+1]; break;
                    case 2: x *= num[i+1]; break;
                    case 3: x /= num[i+1]; break;
                }
            }
    
            return (x==m);
        }
    
        private static void out(){
            System.out.print(num[0]);
            for(int i=0; i<k; i++)
                switch (oper[i]){
                    case 0: System.out.print("+"+num[i+1]); continue;
                    case 1: System.out.print("-"+num[i+1]); continue;
                    case 2: System.out.print("*"+num[i+1]); continue;
                    case 3: System.out.print("/"+num[i+1]); continue;
                }
        }
    }
    

    Input & Output

    5 25
    5 2 3 6 7
    2
    2+3*5

    Reference

    王晓东《计算机算法设计与分析》(第3版)P185

    展开全文
  • 6-11 无优先级运算问题 问题描述 给定 n 个正整数和 4 个运算符+、-、*、/,且运算符优先级,如 2+3*5=25。对于任意给定的整数 m,试设计一个算法,用以上给出的 n 个数和 4 个运算符,产生整数 m, 且用的...

    6-11 无优先级运算问题


    问题描述

    给定 n 个正整数和 4 个运算符+、-、*、/,且运算符无优先级,如 2+3*5=25。对于任意给定的整数 m,试设计一个算法,用以上给出的 n 个数和 4 个运算符,产生整数 m, 且用的运算次数最少。给出的 n 个数中每个数最多只能用 1 次,但每种运算符可以任意使用。

    对于给定的 n 个正整数,设计一个优先队列式分支限界法,用最少的无优先级运算次数 产生整数 m。

    数据输入:
    第一行有 2 个正整数 n 和 m。第 2 行是给定的用于运算 的 n 个正整数。


    Java

    package Chapter6FenZhiXianJieFa;
    
    import java.util.PriorityQueue;
    import java.util.Queue;
    import java.util.Scanner;
    
    public class WuYouXianJiYunSuan {
    
        private static class Arit implements Comparable{
            int dep;
            int[] num,oper,flag;
    
            public int compareTo(Object o){
                Arit arit = (Arit) o;
                int result = Integer.compare(dep, arit.dep);
    
                return result;
            }
    
            private void arit(int n){
                num = new int[n];
                oper = new int[n];
                flag = new int[n];
                for(int i=0; i<n; i++) num[i]=oper[i]=flag[i]=0;
                dep = 0;
            }
        }
    
        private static int n,m;
        private static int[] a;
        private static int dep;
    
        public static void main(String[] args){
            Scanner input = new Scanner(System.in);
    
            while(true){
                dep = 0;
    
                n = input.nextInt();
                m = input.nextInt();
    
                a = new int[n];
    
                for(int i=0; i<n; i++)
                    a[i] = input.nextInt();
    
                if(BBArit() == 0) System.out.println("No Solution!");
            }
        }
    
        private static int BBArit(){
            Queue<Arit> H = new PriorityQueue<>();
            Arit E = new Arit();
            E.arit(n);
            while (true){
                if(found(E)) {out(E); return 1;}
                else {
                    for(int i=0; i<n; i++)
                        if(E.flag[i] == 0)
                            for(int j=0; j<4; j++){
                                Arit N = new Arit();
                                N.arit(n);
                                newNode(N,E,i,j,dep);
                                H.add(N);
                            }
                }
                if(H.isEmpty()) return 0;
                E = H.poll();
                dep = E.dep+1;
            }
        }
    
        private static boolean found(Arit E){
            int x = E.num[0];
            for(int i=0; i<E.dep; i++){
                switch (E.oper[i]){
                    case 0: x+=E.num[i+1]; break;
                    case 1: x-=E.num[i+1]; break;
                    case 2: x*=E.num[i+1]; break;
                    case 3: x/=E.num[i+1]; break;
                }
            }
    
            return (x==m);
        }
    
        private static void out(Arit E){
            System.out.println(E.dep);
            for(int i=0; i<E.dep; i++){
                System.out.print(E.num[i]);
                switch (E.oper[i]){
                    case 0: System.out.print("+"); break;
                    case 1: System.out.print("-"); break;
                    case 2: System.out.print("*"); break;
                    case 3: System.out.print("/"); break;
                }
            }
            System.out.println(E.num[E.dep]);
        }
    
        private static void newNode(Arit N, Arit E, int i, int j, int dep){
            for(int k=0; k<n; k++){
                N.num[k] = E.num[k];
                N.oper[k] = E.oper[k];
                N.flag[k] = E.flag[k];
            }
            N.dep = dep;
            N.oper[dep] = j;
            N.num[dep] = a[i];
            N.flag[i] = 1;
        }
    }
    

    Input & Output

    5 25
    5 2 3 6 7
    2
    3+2*5
    
    
    
    8 1554
    32 23 1 1 26 33 28 5 
    3
    28+33*26-32
    
    
    
    41 48
    34 44 38 38 28 38 39 45 34 19 13 4 36 41 32 30 8 31 10 15 32 27 34 38 4 42 35 49 23 27 18 30 9 6 2 47 47 16 48 9 17 
    0
    48
    

    Reference

    王晓东《计算机算法设计与分析》(第3版)P229

    展开全文
  • C语言编写的无优先级运算问题,C语言编写的无优先级运算问题,C语言编写的无优先级运算问题
  • 给定n个正整数和4个运算符+,-,*,/,且运算符五优先级。对于任意给定的整数m,试设计一个算法,用以上给出的n个数和4个运算符,产生整数m,且用的运算次数最少。给出的n个数只能够每个数最多只能用1次,但每种...
  • 回溯法之无优先级运算问题代码

    千次阅读 2007-04-26 13:29:02
    #include "iostream.h"#include "...//利用给定的数字 运算求出的数字mint num[999];int oper[999];int flag[999];int k; found(){ int x=num[0]; for(int i=0;i&lt;k;i++) { ...

    #include "iostream.h"
    #include "stdio.h"
    int n; //给定数字的个数
    int a[999];//给定的数字
    int m;//利用给定的数字 运算求出的数字m
    int num[999];
    int oper[999];
    int flag[999];
    int k;

    found()
    {
     int x=num[0];
     for(int i=0;i<k;i++)
        {
         switch(oper[i])
            {
             case 0: x+=num[i+1];break;
             case 1: x-=num[i+1];break;
             case 2: x*=num[i+1];break;
             case 3: x/=num[i+1];break;
            }
         }
     return(x==m);
    }

    search(int dep)
    {
     if(dep>k)
       {
        if(found())
        return true;
        else
        return false;
       }
     for(int i=0;i<n;i++)
        if(flag[i]==0)
           {
            num[dep]=a[i];
            flag[i]=1;
            for(int j=0;j<4;j++)
              {
               oper[dep]=j;
               if(search(dep+1))
                  return true;
              }
            flag[i]=0;
           }
      return false;
    }


    main()
    {
     cout<<"输入给定的数字个数 \n";
     cin>>n;
     for (int p=0;p<n;p++)
     {
      cout<<"输入第"<<p+1<<"个数字 \n";
      cin>>a[p];
      flag[p]=0;
     }
     cout<<"输入要求的数字 \n";
     cin>>m;

     for(k=0;k<n;k++)
      if(search(0))
      {
       cout<<k<<"\n";
       //out();
       return;
      }
     cout<<"No Solution! \n";
    }

    展开全文
  • 无优先级运算 回溯 Java

    千次阅读 2013-11-27 14:24:39
    问题描述: 给定n个正整数和4个运算符+,-,*,/,且运算符优先级,...但每种运算符可以任意使用 ★ 算法设计:对于给定的n个正整数,设计一个算法,用最少的无优先级运算次数产生 整数m。  输入: n m  在
  • 无优先级问题

    2013-05-25 23:07:37
    无优先级算法问题
  • 实现大数六则运算的C++小计算器(带包含括号的优先级运算) 六则:加减乘除 乘方 求余 编程的思路发在了这篇文章里 : https://blog.csdn.net/X_P_X_P/article/details/122646365?spm=1001.2014.3001.5501 本人大一 学艺...
  • 无优先级运算--ID-DFS

    千次阅读 2010-09-24 10:41:00
    无优先级运算 问题描述: 给定n 个正整数和4 个运算符+、-、*、/,且运算符优先级,如2+3*5=25。对于 任意给定的整数m,试设计一个算法,用以上给出的n 个数和4 个运算符,产生整数m, 且用的运算次数最少。...
  • 运算优先级

    千次阅读 2021-02-23 20:36:27
    运算优先级 所有的数学运算都认为是从左向右运算的,Java 语言中大部分运算符也是从左向右结合的,只有单目运算符、赋值运算符和三目运算符例外,其中,单目运算符、赋值运算符和三目运算符是从右向左结合的,也就是...
  • 给定n个正整数和4个运算符+,-,*,/ 且运算符无优先级,如2+3*5=25.对于任意给定的整数m,试设计一个算法,用以上给出的n个数和4个运算符,产生整数m,且用的运算次数最少.给出的n个数中每个数最多只能用一次,但每种运算符...
  • 运算运算优先级

    千次阅读 2021-02-18 11:43:43
    运算 >>>代表符号右移,>>是有符号右移 负数的右移:补码左边补1,之后取原码; 负数的左移:补码右边补0,之后取原码。 补码是反码+1,如果是负数,则第一位为1不变。 例子: 正数:r = 20 ...
  • 基于51单片机的计算器程序加仿真,可以连续计算 ,混合运算没有bug 可以判断加减乘除的运算顺序
  • java计算器含括号可进行优先级运算
  • c语言的运算优先级

    2022-07-28 11:01:35
    c语言的运算优先级
  • 运算与运算符优先级

    千次阅读 2019-07-29 00:07:23
    下面我们来总结一下位运算与运算符优先级 (如果对补码、反码运算不理解或者不明白为什么运算要用补码可以看一下这篇https://blog.csdn.net/weixin_44407699/article/details/96270169) 位运算运算共有以下几...
  • 科学计算器优先级运算——液晶显示 单片机
  • 运算优先级

    万次阅读 多人点赞 2018-07-21 14:23:45
    运算优先级低 所以下面这种写法是可以的 if(s &amp; s &lt;&lt; 1) return 0;//先计算s&lt;&lt;1 还有一个优先级顺序 &gt;&gt; 大于 == 大于 &amp; ...
  • Java运算优先级

    2021-02-26 21:07:10
    Java运算优先级 文章目录Java运算优先级前言具体运算一 算术运算符二 符号位三 逻辑位四 关系运算符五 位运算符六 偷懒运算符总结 前言 其实如果自己写代码的话,如果运算式比较长的时候可以多多使用(),()作为最高...
  • “while”语句中要实现的功能是给变量c赋值,然后与EOF进行比较来终止循环,不幸的是,赋值操作的优先级低于比较操作的优先级,因此c的值是getc(in)与EOF比较的结果,getc(in)的值将被弃掉,因此拷贝生成的文件将是...
  • 今天写归并排序,二分时用了位运算,结果总是出bug:stack overflow 找了半天才发现原因 int mid = left + (right - left)>>1; //错!>>优先级在+后面 int mid = left + ((right-left)>>1); //...
  • c语言运算优先级.docx

    2021-03-15 10:49:18
    c语言运算优先级.docx

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 191,975
精华内容 76,790
关键字:

无优先级运算问题

友情链接: day02.rar