Relevant bibliographies by topics / Dynamic programming. Data structures (Computer science)

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Books
  4. Book chapters
  5. Conference papers

Academic literature on the topic 'Dynamic programming. Data structures (Computer science)'

Author: Grafiati
Published: 4 June 2021
Last updated: 1 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Dynamic programming. Data structures (Computer science).'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Dynamic programming. Data structures (Computer science)"

1

KELLY, PAUL H. J., and OLAV BECKMANN. "GENERATIVE AND ADAPTIVE METHODS IN PERFORMANCE PROGRAMMING." Parallel Processing Letters 15, no. 03 (September 2005): 239–55. http://dx.doi.org/10.1142/s0129626405002192.

Full text
Abstract:
Performance programming is characterized by the need to structure software components to exploit the context of use. Relevant context includes the target processor architecture, the available resources (number of processors, network capacity), prevailing resource contention, the values and shapes of input and intermediate data structures, the schedule and distribution of input data delivery, and the way the results are to be used. This paper concerns adapting to dynamic context: adaptive algorithms, malleable and migrating tasks, and application structures based on dynamic component composition. Adaptive computations use metadata associated with software components — performance models, dependence information, data size and shape. Computation itself is interwoven with planning and optimizing the computation process, using this metadata. This reflective nature motivates metaprogramming techniques. We present a research agenda aimed at developing a modelling framework which allows us to characterize both computation and dynamic adaptation in a way that allows systematic optimization.
APA, Harvard, Vancouver, ISO, and other styles
2

Ahn, Kook Jin, Graham Cormode, Sudipto Guha, Andrew McGregor, and Anthony Wirth. "Correlation Clustering in Data Streams." Algorithmica 83, no. 7 (March 13, 2021): 1980–2017. http://dx.doi.org/10.1007/s00453-021-00816-9.

Full text
Abstract:
AbstractClustering is a fundamental tool for analyzing large data sets. A rich body of work has been devoted to designing data-stream algorithms for the relevant optimization problems such as k-center, k-median, and k-means. Such algorithms need to be both time and and space efficient. In this paper, we address the problem of correlation clustering in the dynamic data stream model. The stream consists of updates to the edge weights of a graph on n nodes and the goal is to find a node-partition such that the end-points of negative-weight edges are typically in different clusters whereas the end-points of positive-weight edges are typically in the same cluster. We present polynomial-time, $$O(n\cdot {{\,\mathrm{polylog}\,}}n)$$ O ( n · polylog n ) -space approximation algorithms for natural problems that arise. We first develop data structures based on linear sketches that allow the “quality” of a given node-partition to be measured. We then combine these data structures with convex programming and sampling techniques to solve the relevant approximation problem. Unfortunately, the standard LP and SDP formulations are not obviously solvable in $$O(n\cdot {{\,\mathrm{polylog}\,}}n)$$ O ( n · polylog n ) -space. Our work presents space-efficient algorithms for the convex programming required, as well as approaches to reduce the adaptivity of the sampling.
APA, Harvard, Vancouver, ISO, and other styles
3

ALDINUCCI, MARCO. "${\mathsf{eskimo}}$: EXPERIMENTING WITH SKELETONS IN THE SHARED ADDRESS MODEL." Parallel Processing Letters 13, no. 03 (September 2003): 449–60. http://dx.doi.org/10.1142/s0129626403001410.

Full text
Abstract:
We discuss the lack of expressivity in some skeleton-based parallel programming frameworks. The problem is further exacerbated when approaching irregular problems and dealing with dynamic data structures. Shared memory programming has been argued to have substantial ease of programming advantages for this class of problems. We present the [Formula: see text] library which represents an attempt to merge the two programming models by introducing skeletons in a shared memory framework.
APA, Harvard, Vancouver, ISO, and other styles
4

MUKHOPADHYAY, RISHI, STEPHANIE IRAUSQUIN, CHRISTOPHER SCHMIDT, and HOMAYOUN VALAFAR. "DYNAFOLD: A DYNAMIC PROGRAMMING APPROACH TO PROTEIN BACKBONE STRUCTURE DETERMINATION FROM MINIMAL SETS OF RESIDUAL DIPOLAR COUPLINGS." Journal of Bioinformatics and Computational Biology 12, no. 01 (January 28, 2014): 1450002. http://dx.doi.org/10.1142/s0219720014500024.

Full text
Abstract:
Residual Dipolar Couplings (RDCs) are a source of NMR data that can provide a powerful set of constraints on the orientation of inter-nuclear vectors, and are quickly becoming a larger part of the experimental toolset for molecular biologists. However, few reliable protocols exist for the determination of protein backbone structures from small sets of RDCs. DynaFold is a new dynamic programming algorithm designed specifically for this task, using minimal sets of RDCs collected in multiple alignment media. DynaFold was first tested utilizing synthetic data generated for the N – H , C α– H α, and C – N vectors of 1BRF, 1F53, 110M, and 3LAY proteins, with up to ±1 Hz error in three alignment media, and was able to produce structures with less than 1.9 Å of the original structures. DynaFold was then tested using experimental data, obtained from the Biological Magnetic Resonance Bank, for proteins PDBID:1P7E and 1D3Z using RDC data from two alignment media. This exercise yielded structures within 1.0 Å of their respective published structures in segments with high data density, and less than 1.9 Å over the entire protein. The same sets of RDC data were also used in comparisons with traditional methods for analysis of RDCs, which failed to match the accuracy of DynaFold's approach to structure determination.
APA, Harvard, Vancouver, ISO, and other styles
5

BLIEM, BERNHARD, MICHAEL MORAK, and STEFAN WOLTRAN. "D-FLAT: Declarative problem solving using tree decompositions and answer-set programming." Theory and Practice of Logic Programming 12, no. 4-5 (July 2012): 445–64. http://dx.doi.org/10.1017/s1471068412000129.

Full text
Abstract:
AbstractIn this work, we propose Answer-Set Programming (ASP) as a tool for rapid prototyping of dynamic programming algorithms based on tree decompositions. In fact, many such algorithms have been designed, but only a few of them found their way into implementation. The main obstacle is the lack of easy-to-use systems which (i) take care of building a tree decomposition and (ii) provide an interface for declarative specifications of dynamic programming algorithms. In this paper, we present D-FLAT, a novel tool that relieves the user of having to handle all the technical details concerned with parsing, tree decomposition, the handling of data structures, etc. Instead, it is only the dynamic programming algorithm itself which has to be specified in the ASP language. D-FLAT employs an ASP solver in order to compute the local solutions in the dynamic programming algorithm. In the paper, we give a few examples illustrating the use of D-FLAT and describe the main features of the system. Moreover, we report experiments which show that ASP-based D-FLAT encodings for some problems outperform monolithic ASP encodings on instances of small treewidth.
APA, Harvard, Vancouver, ISO, and other styles
6

Merrell, David, and Anthony Gitter. "Inferring signaling pathways with probabilistic programming." Bioinformatics 36, Supplement_2 (December 2020): i822—i830. http://dx.doi.org/10.1093/bioinformatics/btaa861.

Full text
Abstract:
Abstract Motivation Cells regulate themselves via dizzyingly complex biochemical processes called signaling pathways. These are usually depicted as a network, where nodes represent proteins and edges indicate their influence on each other. In order to understand diseases and therapies at the cellular level, it is crucial to have an accurate understanding of the signaling pathways at work. Since signaling pathways can be modified by disease, the ability to infer signaling pathways from condition- or patient-specific data is highly valuable. A variety of techniques exist for inferring signaling pathways. We build on past works that formulate signaling pathway inference as a Dynamic Bayesian Network structure estimation problem on phosphoproteomic time course data. We take a Bayesian approach, using Markov Chain Monte Carlo to estimate a posterior distribution over possible Dynamic Bayesian Network structures. Our primary contributions are (i) a novel proposal distribution that efficiently samples sparse graphs and (ii) the relaxation of common restrictive modeling assumptions. Results We implement our method, named Sparse Signaling Pathway Sampling, in Julia using the Gen probabilistic programming language. Probabilistic programming is a powerful methodology for building statistical models. The resulting code is modular, extensible and legible. The Gen language, in particular, allows us to customize our inference procedure for biological graphs and ensure efficient sampling. We evaluate our algorithm on simulated data and the HPN-DREAM pathway reconstruction challenge, comparing our performance against a variety of baseline methods. Our results demonstrate the vast potential for probabilistic programming, and Gen specifically, for biological network inference. Availability and implementation Find the full codebase at https://github.com/gitter-lab/ssps. Supplementary information Supplementary data are available at Bioinformatics online.
APA, Harvard, Vancouver, ISO, and other styles
7

Silapachote, Piyanuch, and Ananta Srisuphab. "Engineering Courses on Computational Thinking Through Solving Problems in Artificial Intelligence." International Journal of Engineering Pedagogy (iJEP) 7, no. 3 (September 29, 2017): 34. http://dx.doi.org/10.3991/ijep.v7i3.6951.

Full text
Abstract:
Computational thinking sits at the core of every engineering and computing related discipline. It has increasingly emerged as its own subject in all levels of education. It is a powerful cornerstone for cognitive development, creative problem solving, algorithmic thinking and designs, and programming. How to effectively teach computational thinking skills poses real challenges and creates opportunities. Targeting entering computer science and engineering undergraduates, we resourcefully integrate elements from artificial intelligence (AI) into introductory computing courses. In addition to comprehension of the essence of computational thinking, practical exercises in AI enable inspirations of collaborative problem solving beyond abstraction, logical reasoning, critical and analytical thinking. Problems in machine intelligence systems intrinsically connect students to algorithmic oriented computing and essential mathematical foundations. Beyond knowledge representation, AI fosters a gentle introduction to data structures and algorithms. Focused on engaging mental tool, a computer is never a necessity. Neither coding nor programming is ever required. Instead, students enjoy constructivist classrooms designed to always be active, flexible, and highly dynamic. Learning to learn and reflecting on cognitive experiences, they rigorously construct knowledge from collectively solving exciting puzzles, competing in strategic games, and participating in intellectual discussions.
APA, Harvard, Vancouver, ISO, and other styles
8

POOLSAP, UNYANEE, YUKI KATO, KENGO SATO, and TATSUYA AKUTSU. "USING BINDING PROFILES TO PREDICT BINDING SITES OF TARGET RNAs." Journal of Bioinformatics and Computational Biology 09, no. 06 (December 2011): 697–713. http://dx.doi.org/10.1142/s0219720011005628.

Full text
Abstract:
Prediction of RNA–RNA interaction is a key to elucidating possible functions of small non-coding RNAs, and a number of computational methods have been proposed to analyze interacting RNA secondary structures. In this article, we focus on predicting binding sites of target RNAs that are expected to interact with regulatory antisense RNAs in a general form of interaction. For this purpose, we propose bistaRNA, a novel method for predicting multiple binding sites of target RNAs. bistaRNA employs binding profiles that represent scores for hybridized structures, leading to reducing the computational cost for interaction prediction. bistaRNA considers an ensemble of equilibrium interacting structures and seeks to maximize expected accuracy using dynamic programming. Experimental results on real interaction data validate good accuracy and fast computation time of bistaRNA as compared with several competitive methods. Moreover, we aim to find new targets given specific antisense RNAs, which provides interesting insights into antisense RNA regulation. bistaRNA is implemented in C++. The program and Supplementary Material are available at .
APA, Harvard, Vancouver, ISO, and other styles
9

Li, Jin, Chengzhen Xu, Lei Wang, Hong Liang, Weixing Feng, Zhongxi Cai, Ying Wang, Wang Cong, and Yunlong Liu. "PSRna: Prediction of small RNA secondary structures based on reverse complementary folding method." Journal of Bioinformatics and Computational Biology 14, no. 04 (August 2016): 1643001. http://dx.doi.org/10.1142/s0219720016430010.

Full text
Abstract:
Prediction of RNA secondary structures is an important problem in computational biology and bioinformatics, since RNA secondary structures are fundamental for functional analysis of RNA molecules. However, small RNA secondary structures are scarce and few algorithms have been specifically designed for predicting the secondary structures of small RNAs. Here we propose an algorithm named “PSRna” for predicting small-RNA secondary structures using reverse complementary folding and characteristic hairpin loops of small RNAs. Unlike traditional algorithms that usually generate multi-branch loops and 5[Formula: see text] end self-folding, PSRna first estimated the maximum number of base pairs of RNA secondary structures based on the dynamic programming algorithm and a path matrix is constructed at the same time. Second, the backtracking paths are extracted from the path matrix based on backtracking algorithm, and each backtracking path represents a secondary structure. To improve accuracy, the predicted RNA secondary structures are filtered based on their free energy, where only the secondary structure with the minimum free energy was identified as the candidate secondary structure. Our experiments on real data show that the proposed algorithm is superior to two popular methods, RNAfold and RNAstructure, in terms of sensitivity, specificity and Matthews correlation coefficient (MCC).
APA, Harvard, Vancouver, ISO, and other styles
10

WANG, SHENG, and WEI-MOU ZHENG. "CLePAPS: FAST PAIR ALIGNMENT OF PROTEIN STRUCTURES BASED ON CONFORMATIONAL LETTERS." Journal of Bioinformatics and Computational Biology 06, no. 02 (April 2008): 347–66. http://dx.doi.org/10.1142/s0219720008003461.

Full text
Abstract:
Fast, efficient, and reliable algorithms for pairwise alignment of protein structures are in ever-increasing demand for analyzing the rapidly growing data on protein structures. CLePAPS is a tool developed for this purpose. It distinguishes itself from other existing algorithms by the use of conformational letters, which are discretized states of 3D segmental structural states. A letter corresponds to a cluster of combinations of the three angles formed by Cα pseudobonds of four contiguous residues. A substitution matrix called CLESUM is available to measure the similarity between any two such letters. CLePAPS regards an aligned fragment pair (AFP) as an ungapped string pair with a high sum of pairwise CLESUM scores. Using CLESUM scores as the similarity measure, CLePAPS searches for AFPs by simple string comparison. The transformation which best superimposes a highly similar AFP can be used to superimpose the structure pairs under comparison. A highly scored AFP which is consistent with several other AFPs determines an initial alignment. CLePAPS then joins consistent AFPs guided by their similarity scores to extend the alignment by several "zoom-in" iteration steps. A follow-up refinement produces the final alignment. CLePAPS does not implement dynamic programming. The utility of CLePAPS is tested on various protein structure pairs.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Dynamic programming. Data structures (Computer science)"

1

Zhu, Yingchun 1968. "Optimizing parallel programs with dynamic data structures." Thesis, McGill University, 2000. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=36745.

Full text
Abstract:
Distributed memory parallel architectures support a memory model where some memory accesses are local, and thus inexpensive, while other memory accesses are remote, and potentially quite expensive. In order to achieve efficiency on such architectures, we need to reduce remote accesses. This is particularly challenging for applications that use dynamic data structures.
In this thesis, I present two compiler techniques to reduce the overhead of remote memory accesses for dynamic data structure based applications: locality techniques and communication optimizations. Locality techniques include a static locality analysis, which statically estimates when an indirect reference via a pointer can be safely assumed to be a local access, and dynamic locality checks, which consists of runtime tests to identify local accesses. Communication techniques include: (1) code movement to issue remote reads earlier and writes later; (2) code transformations to replace repeated/redundant remote accesses with one access; and (3) transformations to block or pipeline a group of remote requests together. Both locality and communication techniques have been implemented and incorporated into our EARTH-McCAT compiler framework, and a series of experiments have been conducted to evaluate these techniques. The experimental results show that we are able to achieve up to 26% performance improvement with each technique alone, and up to 29% performance improvement when both techniques are applied together.
APA, Harvard, Vancouver, ISO, and other styles
2

Kuper, Lindsey. "Lattice-based data structures for deterministic parallel and distributed programming." Thesis, Indiana University, 2015. http://pqdtopen.proquest.com/#viewpdf?dispub=3726443.

Full text
Abstract:

Deterministic-by-construction parallel programming models guarantee that programs have the same observable behavior on every run, promising freedom from bugs caused by schedule nondeterminism. To make that guarantee, though, they must sharply restrict sharing of state between parallel tasks, usually either by disallowing sharing entirely or by restricting it to one type of data structure, such as single-assignment locations.

I show that lattice-based data structures, or LVars, are the foundation for a guaranteed-deterministic parallel programming model that allows a more general form of sharing. LVars allow multiple assignments that are inflationary with respect to a given lattice. They ensure determinism by allowing only inflationary writes and "threshold" reads that block until a lower bound is reached. After presenting the basic LVars model, I extend it to support event handlers, which enable an event-driven programming style, and non-blocking "freezing" reads, resulting in a quasi-deterministic model in which programs behave deterministically modulo exceptions.

I demonstrate the viability of the LVars model with LVish, a Haskell library that provides a collection of lattice-based data structures, a work-stealing scheduler, and a monad in which LVar computations run. LVish leverages Haskell's type system to index such computations with effect levels to ensure that only certain LVar effects can occur, hence statically enforcing determinism or quasi-determinism. I present two case studies of parallelizing existing programs using LVish: a k-CFA control flow analysis, and a bioinformatics application for comparing phylogenetic trees.

Finally, I show how LVar-style threshold reads apply to the setting of convergent replicated data types (CvRDTs), which specify the behavior of eventually consistent replicated objects in a distributed system. I extend the CvRDT model to support deterministic, strongly consistent threshold queries. The technique generalizes to any lattice, and hence any CvRDT, and allows deterministic observations to be made of replicated objects before the replicas' states converge.

APA, Harvard, Vancouver, ISO, and other styles
3

Robson, R. "Data views for a programming environment." Thesis, McGill University, 1988. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=75754.

Full text
Abstract:
A data structure editor is presented for use in an integrated, fragment-based programming environment. This editor employs high resolution computer graphics to present the user with an iconic representation of the internal storage of a running program.
The editor allows the creation, modification, and deletion of data structures. These abilities allow the user to quickly sketch data structures with which to test incomplete program fragments, alleviating the need for driver routines.
To keep the user cognizant of events inside his program, a technique for automated display management is presented allowing the user to keep the most important objects in the viewport at all times. A history facility permits the user to see the former values of all variables.
Execution controls are provided allowing the user to control the scope and speed of execution, manipulate frames on the run-time stack, set breakpoints, and profile the executing algorithm.
APA, Harvard, Vancouver, ISO, and other styles
4

McCallen, Scott J. "Mining Dynamic Structures in Complex Networks." Kent State University / OhioLINK, 2007. http://rave.ohiolink.edu/etdc/view?acc_num=kent1204154279.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Lindblad, Christopher John. "A programming system for the dynamic manipulation of temporally sensitive data." Thesis, Massachusetts Institute of Technology, 1994. http://hdl.handle.net/1721.1/37744.

Full text
Abstract:
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1994.
Includes bibliographical references (p. 255-277).
by Christopher John Lindblad.
Ph.D.
APA, Harvard, Vancouver, ISO, and other styles
6

Cain, Andrew Angus, and n/a. "Dynamic data flow analysis for object oriented programs." Swinburne University of Technology, 2005. http://adt.lib.swin.edu.au./public/adt-VSWT20060904.161506.

Full text
Abstract:
There are many tools and techniques to help developers debug and test their programs. Dynamic data flow analysis is such a technique. Existing approaches for performing dynamic data flow analysis for object oriented programs have tended to be data focused and procedural in nature. An approach to dynamic data flow analysis that used object oriented principals would provide a more natural solution to analysing object oriented programs. Dynamic data flow analysis approaches consist of two primary aspects; a model of the data flow information, and a method for collecting action information from a running program. The model for data flow analysis presented in this thesis uses a meta-level object oriented approach. To illustrate the application of this meta-level model, a model for the Java programming language is presented. This provides an instantiation of the meta-level model provided. Finally, several methods are presented for collecting action information from Java programs. The meta-level model contains elements to represent both data items and scoping components (i.e. methods, blocks, objects, and classes). At runtime the model is used to create a representation of the executing program that is used to perform dynamic data flow analysis. The structure of the model is created in such a way that locating the appropriate meta-level entity follows the scoping rules of the language. In this way actions that are reported to the meta-model are routed through the model to their corresponding meta-level elements. The Java model presented contains classes that can be used to create the runtime representation of the program under analysis. Events from the program under analysis are then used to update the model. Using this information developers are able to locate where data items are incorrectly used within their programs. Methods for collecting action information from Java programs include source code instrumentation, as used in earlier approaches, and approaches that use Java byte code transformation, and the facilities of the Java Platform Debugger Architecture. While these approaches aimed to achieve a comprehensive analysis, there are several issues that could not be resolved using the approaches covered. Of the approaches presented byte code transformation is the most practical.
APA, Harvard, Vancouver, ISO, and other styles
7

Jones, Anthony Andrew. "Combining data driven programming with component based software development : with applications in geovisualisation and dynamic data driven application systems." Thesis, Aston University, 2008. http://publications.aston.ac.uk/10682/.

Full text
Abstract:
Software development methodologies are becoming increasingly abstract, progressing from low level assembly and implementation languages such as C and Ada, to component based approaches that can be used to assemble applications using technologies such as JavaBeans and the .NET framework. Meanwhile, model driven approaches emphasise the role of higher level models and notations, and embody a process of automatically deriving lower level representations and concrete software implementations.
APA, Harvard, Vancouver, ISO, and other styles
8

Jain, Jhilmil Cross James H. "User experience design and experimental evaluation of extensible and dynamic viewers for data structures." Auburn, Ala., 2007. http://repo.lib.auburn.edu/2006%20Fall/Dissertations/JAIN_JHILMIL_3.pdf.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Harrison, William. "Malleability, obliviousness and aspects for broadcast service attachment." Universität Potsdam, 2010. http://opus.kobv.de/ubp/volltexte/2010/4138/.

Full text
Abstract:
An important characteristic of Service-Oriented Architectures is that clients do not depend on the service implementation's internal assignment of methods to objects. It is perhaps the most important technical characteristic that differentiates them from more common object-oriented solutions. This characteristic makes clients and services malleable, allowing them to be rearranged at run-time as circumstances change. That improvement in malleability is impaired by requiring clients to direct service requests to particular services. Ideally, the clients are totally oblivious to the service structure, as they are to aspect structure in aspect-oriented software. Removing knowledge of a method implementation's location, whether in object or service, requires re-defining the boundary line between programming language and middleware, making clearer specification of dependence on protocols, and bringing the transaction-like concept of failure scopes into language semantics as well. This paper explores consequences and advantages of a transition from object-request brokering to service-request brokering, including the potential to improve our ability to write more parallel software.
APA, Harvard, Vancouver, ISO, and other styles
10

Palix, Nicolas, Julia L. Lawall, Gaël Thomas, and Gilles Muller. "How Often do Experts Make Mistakes?" Universität Potsdam, 2010. http://opus.kobv.de/ubp/volltexte/2010/4132/.

Full text
Abstract:
Large open-source software projects involve developers with a wide variety of backgrounds and expertise. Such software projects furthermore include many internal APIs that developers must understand and use properly. According to the intended purpose of these APIs, they are more or less frequently used, and used by developers with more or less expertise. In this paper, we study the impact of usage patterns and developer expertise on the rate of defects occurring in the use of internal APIs. For this preliminary study, we focus on memory management APIs in the Linux kernel, as the use of these has been shown to be highly error prone in previous work. We study defect rates and developer expertise, to consider e.g., whether widely used APIs are more defect prone because they are used by less experienced developers, or whether defects in widely used APIs are more likely to be fixed.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Books on the topic "Dynamic programming. Data structures (Computer science)"

1

Genetic programming and data structures: Genetic programming + data structures = automatic programming! Boston: Kluwer Academic Publishers, 1998.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
2

Wilson, Raymond. An introduction to dynamic data structures. London: McGraw-Hill, 1988.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
3

Programming structures. New York: Prentice Hall, 1990.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
4

Dynamic data structures: Theory and application. San Diego: Academic Press, 1992.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
5

An introduction to dynamic data structures. London: McGraw-Hill, 1988.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
6

Java: Data structures and programming. New York: Springer, 1998.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
7

Knapp, Judith. Data structures for business programming. Watsonville, Calif: Mitchell Pub., 1989.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
8

Kruse, Robert L. Programming with data structures: Pascal version. Englewood Cliffs, N.J: Prentice Hall, 1989.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
9

Advanced programming and data structures usingPASCAL. Boston: PWS-KENT Pub. Co, 1990.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
10

Data structures, algorithms, and object-oriented programming. New York: McGraw-Hill, 1996.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
More sources

Book chapters on the topic "Dynamic programming. Data structures (Computer science)"

1

Raman, Rajeev, Venkatesh Raman, and S. Srinivasa Rao. "Succinct Dynamic Data Structures." In Lecture Notes in Computer Science, 426–37. Berlin, Heidelberg: Springer Berlin Heidelberg, 2001. http://dx.doi.org/10.1007/3-540-44634-6_39.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Italiano, Giuseppe F., Alberto Marchetti Spaccamela, and Umberto Nanni. "Dynamic data structures for series parallel digraphs." In Lecture Notes in Computer Science, 352–72. Berlin, Heidelberg: Springer Berlin Heidelberg, 1989. http://dx.doi.org/10.1007/3-540-51542-9_30.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Badeau, Frédéric, Vincent Lacroix, Vincent Monfort, Laurent Voisin, and Christophe Métayer. "Modelling Dynamic Data Structures with the B Method." In Lecture Notes in Computer Science, 420–24. Cham: Springer International Publishing, 2018. http://dx.doi.org/10.1007/978-3-319-91271-4_34.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

He, Meng, and J. Ian Munro. "Space Efficient Data Structures for Dynamic Orthogonal Range Counting." In Lecture Notes in Computer Science, 500–511. Berlin, Heidelberg: Springer Berlin Heidelberg, 2011. http://dx.doi.org/10.1007/978-3-642-22300-6_42.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Efrat, Alon, Matthew J. Katz, Franck Nielsen, and Micha Sharir. "Dynamic data structures for fat objects and their applications." In Lecture Notes in Computer Science, 297–306. Berlin, Heidelberg: Springer Berlin Heidelberg, 1997. http://dx.doi.org/10.1007/3-540-63307-3_69.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Feinsilver, P., and R. Schott. "An operator calculus approach to the evolution of dynamic data structures." In Lecture Notes in Computer Science, 574–86. Berlin, Heidelberg: Springer Berlin Heidelberg, 1995. http://dx.doi.org/10.1007/3-540-60246-1_162.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Alexandron, Giora, Haim Kaplan, and Micha Sharir. "Kinetic and Dynamic Data Structures for Convex Hulls and Upper Envelopes." In Lecture Notes in Computer Science, 269–81. Berlin, Heidelberg: Springer Berlin Heidelberg, 2005. http://dx.doi.org/10.1007/11534273_24.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Zhao, Hui, Meikang Qiu, Keke Gai, Jie Li, and Xin He. "Cost Reduction for Data Allocation in Heterogenous Cloud Computing Using Dynamic Programming." In Lecture Notes in Computer Science, 1–11. Cham: Springer International Publishing, 2017. http://dx.doi.org/10.1007/978-3-319-52015-5_1.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Goujon, Delphine Stéphanie, Martial Michel, Jasper Peeters, and Judith Ellen Devaney. "AutoMap and AutoLink tools for communicating complex and dynamic data-structures using MPI." In Lecture Notes in Computer Science, 98–109. Berlin, Heidelberg: Springer Berlin Heidelberg, 1998. http://dx.doi.org/10.1007/bfb0052210.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Herlihy, Maurice, Victor Luchangco, and Mark Moir. "The Repeat Offender Problem: A Mechanism for Supporting Dynamic-Sized, Lock-Free Data Structures." In Lecture Notes in Computer Science, 339–53. Berlin, Heidelberg: Springer Berlin Heidelberg, 2002. http://dx.doi.org/10.1007/3-540-36108-1_23.

Full text
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Dynamic programming. Data structures (Computer science)"

1

Delgado, Guillermo, and Chatchawit Aporntewan. "Data dependency reduction in Dynamic Programming matrix." In 2011 International Joint Conference on Computer Science and Software Engineering (JCSSE). IEEE, 2011. http://dx.doi.org/10.1109/jcsse.2011.5930126.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Lovett, Shachar, and Ely Porat. "A Lower Bound for Dynamic Approximate Membership Data Structures." In 2010 IEEE 51st Annual Symposium on Foundations of Computer Science (FOCS). IEEE, 2010. http://dx.doi.org/10.1109/focs.2010.81.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Knorr, Edwin M., and Christopher Thompson. "In-Lab Programming Tests in a Data Structures Course in C for Non-Specialists." In SIGCSE '17: The 48th ACM Technical Symposium on Computer Science Education. New York, NY, USA: ACM, 2017. http://dx.doi.org/10.1145/3017680.3017766.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Fojcik, Martyna K., and Marcin Fojcik. "TEACHERS EXPERIENCE WITH INTRODUCING PROGRAMMING IN DIFFERENT COURSES FOR NON-COMPUTER SCIENCE STUDENTS." In International Conference on Education and New Developments. inScience Press, 2021. http://dx.doi.org/10.36315/2021end104.

Full text
Abstract:
Digital literacy has become more and more important in the last decade, and many people predict that in the future, the need for digital skills will be even more crucial than it is today. The dynamic development and use of technology are becoming increasingly common in all areas of life, changing demands of modern life and the labor market, which makes it necessary to educate students from many different study-programs on how to use different digital tools and how to program. Depending on different professions, there are different requirements on what it means to have digital literacy. For some it is most important to know how technologies are created or to use the product effectively, for others it is the security of data transfer that is essential. The different professions have different needs for digital literacy and different use for programming skills. Teaching computer programming can be particularly difficult in the case of introducing programming for non-computer scientists. While computer science itself (programming) is relatively well described in the subject’s literature, the use of programming in other professions is not well defined. There are different suggestions, recommendations according to the level of education (primary, secondary, higher) or the study-programs the students take. There is no definition of what digital literacy is in different professions, what it means to know computer programming in different professions, and to what extend the students from non-computer science courses should master digital literacy and programming. That can cause challenges for the teachers and students in non-computer science professions that are required to know computer programming for their future jobs. There is no doubt that academic computer science skills for non-programmers can mean/contain different knowledge depending on course curriculum, teachers' experience, chosen literature, but the level of obtaining digital skills should be comparable, adequate, and relevant for the modern citizen. This article presents requirements, some descriptions/cases of introduction to programming for non-computer scientists from a teacher’s perspective. An adaptation of the general programming knowledge into the specific need of different subjects. The data is collected from higher education teachers that have different backgrounds and are teaching at different study-programs to get various views and experiences. The analysis of the findings uses SOLO-taxonomy to compare to what extend the different courses introduce programming to students.
APA, Harvard, Vancouver, ISO, and other styles
5

Rodríguez, Inmaculada, Maria Salamó, and Anna Puig. "Design and Evaluation of Gamification Experiences in Computer Science Studies." In Sixth International Conference on Higher Education Advances. Valencia: Universitat Politècnica de València, 2020. http://dx.doi.org/10.4995/head20.2020.11212.

Full text
Abstract:
This paper presents two gamification experiences developed in the Computer Science (CS) degree at the University of Barcelona. Usually, the CS degree suffers from low class attendance, which impacts the participation of students in in-class programming activities. Additionally, this degree includes a basic course related to human computer interaction that, despite of being valuable for the formation of students, they feel as boring and useless, far from their - heavily computer focused - interests. Then we decided to gamify a basic course of programming skills and the mentioned HCI course. We decided to use two different formats, online and physical. First, one experience was performed in “Human Factors in Computing” course of third year of studies, with 70 enrolled students. First, students attended to a 3D online theoretical class related to emotional design in “The education district” (TED) platform, which is a 3D Virtual World (VW) for educational purposes, developed by Virtway corporation. Afterwards, they participated in the ‘Game of thrones’ gamified activity where they evaluated the usability of TED. Second, we designed ‘physical’ gamified classes to increase attendance to Data Structures course, and in consequence, augment the number of programming exercises that students perform and the assistance they receive from the teacher. During the gamified sessions, the 120 enrolled students enhanced their skills in solving programming problems. The experience consisted of three kinds of challenges (with easy, medium, and hard difficulty level) solved in large, medium, and low-sized groups of students, respectively. The results of both experiences were satisfactory as evidenced by the percentage of students (>=66,7%) that rated the activities between 6 and 10 (in a 0 to 10 scale).
APA, Harvard, Vancouver, ISO, and other styles
6

Jusic, Samir, and Lee Sai Peck. "PersistF: A Transparent Persistence Framework with Architecture Applying Design Patterns." In InSITE 2007: Informing Science + IT Education Conference. Informing Science Institute, 2007. http://dx.doi.org/10.28945/3176.

Full text
Abstract:
Persistence is the term used in computer science to describe a capability to store data structures in non-volatile storage such as a file system or a relational database (Wikipedia, 2003). There is a growing need to simplify the interactions among separate systems and to build complex software systems that are made out of components with well-defined services. At the base-level of such complex systems lies a persistence framework - a set of classes tailored to save, retrieve, update and delete objects to and from their persistence stores, such as databases and flat files. This paper presents the design, and implementation of the transparent persistence framework called PersistF. Design patterns (Gamma, Helm, Johnson, & Vlissides, 1995) have been widely accepted in the software engineering community as the recommended approach to developing software. Part of the research effort of this work included the application of well-known design patterns in order to build the framework. We present how consistent application of design patterns allowed us to build a fully working persistence framework. In order to support development of modern complex applications, some recent application development environments for different programming languages are built in with some kind of persistence framework. To use these frameworks in target applications, the developer often must go through a steep learning curve as each framework is specific in some way, but namely in respect of configuring the framework’s runtime engine with enough information about the domain application. This configuration is often time consuming and error prone. Most of the existing frameworks require complicated configuration steps that are imposed onto the developer. Our aim with this work was to present a framework that will not require such complicated configuration steps and would provide its service to the target application with virtually no configuration of the framework's handling of domain classes.
APA, Harvard, Vancouver, ISO, and other styles
7

Steuben, John, and Cameron J. Turner. "Waypoint-Based Robot Navigation Using NURBs-Based Metamodels." In ASME 2011 International Mechanical Engineering Congress and Exposition. ASMEDC, 2011. http://dx.doi.org/10.1115/imece2011-62450.

Full text
Abstract:
Effective path planning techniques for mobile robots have potential uses and ramifications in a wide range of fields. As a result, the study of these techniques is highly diverse, and historically rich. In this vein we present a path planning methodology for a particular type of robot — one which flies above a terrain but must periodically land at waypoints. The approach demonstrated here is notable for drawing its inspiration and working basis from several different engineering fields. NURBs-based metamodels, a concept developed in the field of engineering design, are used to represent terrain to be navigated. Goal programming, largely used in operations research, is used to determine optimal landing waypoints. Graph theory concepts (derived from the field of computer science) are used to generate robot paths, and more broadly as data structures for information management. We demonstrate the new method on a variety of terrain maps, and present our conclusions on the effectiveness of the algorithm. We close with remarks regarding potential future developments and improvements that may be made to increase the utility of this approach.
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Dynamic programming. Data structures (Computer science)' for particular source types:
Journal articles Dissertations / Theses Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography