Binary 查找给定输入的最小二进制小数数-n。

如果数字中的所有数字都应为“1”或“0”，则称该数字为二进制十进制数。任何数字都可以写成二进制小数的和。我们的任务是找到表示一个数字的最小二进制小数数。

输入：32 输出：10 11

输入：120 输出：10 110

什么是解决这个问题的有效方法？

举个例子

答案是

11111

11110

11100

11000

一万

<>将其视为m×n矩阵，其中m是给定数的n的最大值，n是位数。然后用等于该列对应数字值的1填充列，其余用0填充

        #include<iostream>

        using namespace std;
        int max(int arr[],int c)
        {
            int max=arr[0];
            for(int i=1;i<c;i++){
                if(arr[i]>max){
                    max=arr[i];
                }
            }
            return max;
        }
        int main() {
            int n,x,c=0,i=0,j=0;
            cin>>n;
            x=n;
            while(n!=0){
                n=n/10;
                c++;
            }
            int *a=new int[c];

            while(x!=0){
                a[i]=x%10;
                x=x/10;
                i++;
            }
            int r=max(a,c);
            int ans[r][c];
            for(int i=0;i<c;i++)
            {
                for(int j=0;j<r;j++)
                {
                    if(a[c-i-1]!=0){
                        ans[j][i]=1;
                        a[c-i-1]--;
                    }
                    else
                        ans[j][i]=0;
                }
            }
            for(i=0;i<r;i++){
                for(j=0;j<c;j++){
                    cout<<ans[i][j];
                }
                cout<<"\n";
            }

            }

#包括
使用名称空间std；
整数最大值（整数arr[]，整数c）
{
int max=arr[0]；
对于（int i=1；imax）{
max=arr[i]；
}
}
返回最大值；
}
int main（）{
int n，x，c=0，i=0，j=0；
cin>>n；
x=n；
而（n！=0）{
n=n/10；
C++；
}
int*a=新的int[c]；
而（x！=0）{
a[i]=x%10；
x=x/10；
i++；
}
int r=最大值（a，c）；
int ans[r][c]；
对于（inti=0；i我已经用DP解决了这个问题。可能没有前一个好。但这可能是另一种方法

import java.util.ArrayList;
import java.util.*;
class Deci_binary
{
public static void main(String ars[])
{
    Scanner sc=new Scanner(System.in);
    Deci_binary Db=new Deci_binary();
    Db.deci_binary(sc.nextInt());
}
public void deci_binary(int input)
{
    String input_string=input+"";
    int length=input_string.length();
    ArrayList<Integer> combination=combination(length);
    ArrayList dp[]=new ArrayList[input+1];
    ArrayList<Integer> empty=new ArrayList<Integer>();
    dp[0]=empty;
    int combination_size=combination.size();
    for(int i=1;i<=input;i++)
    {
        dp[i]=null;
        for(int j=0;j<combination_size;j++)
        {
            int combination_get=combination.get(j);
            if(i>=combination_get)
            {
                ArrayList<Integer> previous=new ArrayList<Integer>(dp[i-combination_get]);
                previous.add(combination_get);
                dp[i]=min(dp[i],previous);
            }
            else{
                break;
            }
        }
    }
    System.out.println(dp[input]);

}
public ArrayList<Integer> min(ArrayList<Integer> first,ArrayList<Integer> second)
{
    if(first==null)
    {
        return second;
    }
    else{
        int first_size=first.size();
        int second_size=second.size();
        if(first_size<second_size)
        {
            return first;
        }
        else{
            return second;
        }
    }
}
public ArrayList<Integer> combination(int number)//this will give all the combinations of binary number having x number of digits
{

    int last_number=(int)Math.pow(2,number);
    ArrayList<Integer> combination=new ArrayList<Integer>(last_number-1);
    for(int i=1;i<last_number;i++)
    {
        combination.add(Integer.parseInt(Integer.toBinaryString(i)));            
    }
    return combination;
}
}

import java.util.ArrayList；
导入java.util.*；
类十进制二进制
{
公共静态void main（字符串ars[]）
{
扫描仪sc=新的扫描仪（System.in）；
Deci_binary Db=新的Deci_binary（）；
Db.deci_二进制（sc.nextInt（））；
}
公共void deci_二进制（int输入）
{
字符串输入\字符串=输入+“”；
int length=input_string.length（）；
ArrayList组合=组合（长度）；
ArrayList dp[]=新的ArrayList[input+1]；
ArrayList empty=新的ArrayList（）；
dp[0]=空；
int composition_size=composition.size（）；
对于（int i=1；i而言，最简单的解决方案是从数字中返回最高的数字。
例如：
82734的答案是

11111

11111

10111

10101

10100

10100

10100

一万

是C++的解决方案。
int solve(int n) {
    string n_str = to_string(n);
    return *max_element(n_str.begin(),n_str.end()) - '0';
}

这是到目前为止我看到的关于这个问题的最好的解决方案。很好。谢谢。